final = Image.new("RGB", (int(dx), int(dy)))
for x in range(cols):
    for y in range(rows):
        dxn = largura * (0.5 + x)
        dyn = altura * (0.5 + y)
        latn, lonn = pixelstolatlon(ulx + dxn, uly - dyn - bottom/2, zoom)
        position = ','.join((str(latn), str(lonn)))
        print x, y, position
        urlparams = urllib.urlencode({'center': position,
                                      'zoom': str(zoom),
                                      'size': '%dx%d' % (largura, alturaplus),
                                      'maptype': 'satellite',
                                      'sensor': 'false',
                                      'scale': scale})
        url = 'http://maps.google.com/maps/api/staticmap?' + urlparams
        f=urllib.urlopen(url)
        im=Image.open(StringIO.StringIO(f.read()))
        final.paste(im, (int(x*largura), int(y*altura)))
final.show()

import webapp2

class MainPage(webapp2.RequestHandler):
    def get(self):
        self.response.headers['Content-Type'] = 'text/plain'
        self.response.write('pyGMapMain-Hello')

app = webapp2.WSGIApplication([('/', MainPage)], debug=True)

application: pygmapengine
version: 1
runtime: python27
api_version: 1
threadsafe: true

handlers:
- url: /.*
  script: pygmapengine.app

 /** Initializes AR application components. */
  private void initApplicationAR() {
      // Do application initialization in native code (e.g. registering
      // callbacks, etc.):
      initApplicationNative(mScreenWidth, mScreenHeight);

      // Create OpenGL ES view:
      int depthSize = 16;
      int stencilSize = 0;
      boolean translucent = QCAR.requiresAlpha();

      mGlView = new QCARSampleGLView(this);
      mGlView.init(mQCARFlags, translucent, depthSize, stencilSize);

      mRenderer = new cameraDemoRenderer();
      mRenderer.mActivity = this;
      mGlView.setRenderer(mRenderer);

      LayoutInflater inflater = LayoutInflater.from(this);
      mUILayout = (RelativeLayout) inflater.inflate(R.layout.activity_main,
              null, false);

      mUILayout.setVisibility(View.VISIBLE);
      mUILayout.setBackgroundColor(Color.BLACK);

      // Gets a reference to the loading dialog
      mLoadingDialogContainer = mUILayout
              .findViewById(R.id.loading_indicator);

      // Shows the loading indicator at start
      loadingDialogHandler.sendEmptyMessage(SHOW_LOADING_DIALOG);

      // Adds the inflated layout to the view
      addContentView(mUILayout, new LayoutParams(LayoutParams.MATCH_PARENT,
              LayoutParams.MATCH_PARENT));
  }

JNIEXPORT void JNICALL
Java_com_qualcomm_QCARSamples_ImageTargets_ImageTargets_initApplicationNative(
                            JNIEnv* env, jobject obj, jint width, jint height)
{
    LOG("Java_com_qualcomm_QCARSamples_ImageTargets_ImageTargets_initApplicationNative");

    // Store screen dimensions
    screenWidth = width;
    screenHeight = height;

    // Handle to the activity class:
    jclass activityClass = env->GetObjectClass(obj);

    jmethodID getTextureCountMethodID = env->GetMethodID(activityClass,
                                                    "getTextureCount", "()I");
    if (getTextureCountMethodID == 0)
    {
        LOG("Function getTextureCount() not found.");
        return;
    }

    textureCount = env->CallIntMethod(obj, getTextureCountMethodID);
    if (!textureCount)
    {
        LOG("getTextureCount() returned zero.");
        return;
    }

    textures = new Texture*[textureCount];

    jmethodID getTextureMethodID = env->GetMethodID(activityClass,
        "getTexture", "(I)Lcom/qualcomm/QCARSamples/ImageTargets/Texture;");

    if (getTextureMethodID == 0)
    {
        LOG("Function getTexture() not found.");
        return;
    }

    // Register the textures
    for (int i = 0; i < textureCount; ++i)
    {

        jobject textureObject = env->CallObjectMethod(obj, getTextureMethodID, i);
        if (textureObject == NULL)
        {
            LOG("GetTexture() returned zero pointer");
            return;
        }

        textures[i] = Texture::create(env, textureObject);
    }
    LOG("Java_com_qualcomm_QCARSamples_ImageTargets_ImageTargets_initApplicationNative finished");
}

    /** An async task to load the tracker data asynchronously. */
    private class LoadTrackerTask extends AsyncTask<Void, Integer, Boolean>
    {
        protected Boolean doInBackground(Void... params)
        {
            // Prevent the onDestroy() method to overlap:
            synchronized (mShutdownLock)
            {
                // Load the tracker data set:
                return (loadTrackerData() > 0);
            }
        }

        protected void onPostExecute(Boolean result)
        {
            DebugLog.LOGD("LoadTrackerTask::onPostExecute: execution " +
                        (result ? "successful" : "failed"));

            if (result)
            {
                // The stones and chips data set is now active:
                mIsStonesAndChipsDataSetActive = true;

                // Done loading the tracker, update application status:
                updateApplicationStatus(APPSTATUS_INITED);
            }
            else
            {
                // Create dialog box for display error:
                AlertDialog dialogError = new AlertDialog.Builder
                (
                    ImageTargets.this
                ).create();

                dialogError.setButton
                (
                    DialogInterface.BUTTON_POSITIVE,
                    "Close",
                    new DialogInterface.OnClickListener()
                    {
                        public void onClick(DialogInterface dialog, int which)
                        {
                            // Exiting application:
                            System.exit(1);
                        }
                    }
                );

                // Show dialog box with error message:
                dialogError.setMessage("Failed to load tracker data.");
                dialogError.show();
            }
        }
    }

JNIEXPORT int JNICALL
Java_com_qualcomm_QCARSamples_ImageTargets_ImageTargets_loadTrackerData(JNIEnv *, jobject)
{
    LOG("Java_com_qualcomm_QCARSamples_ImageTargets_ImageTargets_loadTrackerData");

    // Get the image tracker:
    QCAR::TrackerManager& trackerManager = QCAR::TrackerManager::getInstance();
    QCAR::ImageTracker* imageTracker = static_cast<QCAR::ImageTracker*>(
                    trackerManager.getTracker(QCAR::Tracker::IMAGE_TRACKER));
    if (imageTracker == NULL)
    {
        LOG("Failed to load tracking data set because the ImageTracker has not"
            " been initialized.");
        return 0;
    }

    // Create the data sets:
    dataSetStonesAndChips = imageTracker->createDataSet();
    if (dataSetStonesAndChips == 0)
    {
        LOG("Failed to create a new tracking data.");
        return 0;
    }

    dataSetTarmac = imageTracker->createDataSet();
    if (dataSetTarmac == 0)
    {
        LOG("Failed to create a new tracking data.");
        return 0;
    }

    // Load the data sets:
    if (!dataSetStonesAndChips->load("StonesAndChips.xml", QCAR::DataSet::STORAGE_APPRESOURCE))
    {
        LOG("Failed to load data set.");
        return 0;
    }

    if (!dataSetTarmac->load("Tarmac.xml", QCAR::DataSet::STORAGE_APPRESOURCE))
    //if (!dataSetTarmac->load("FunnyDB.xml", QCAR::DataSet::STORAGE_APPRESOURCE))
    {
        LOG("Failed to load data set.");
        return 0;
    }

    // Activate the data set:
    if (!imageTracker->activateDataSet(dataSetStonesAndChips))
    {
        LOG("Failed to activate data set.");
        return 0;
    }

    LOG("Successfully loaded and activated data set.");
    return 1;
}

QCAR::DataSet* dataSetStonesAndChips    = 0;
QCAR::DataSet* dataSetTarmac            = 0;

JNIEXPORT void JNICALL
Java_com_qualcomm_QCARSamples_ImageTargets_ImageTargets_onQCARInitializedNative(JNIEnv *, jobject)
{
    // Register the update callback where we handle the data set swap:
    QCAR::registerCallback(&updateCallback);

    // Comment in to enable tracking of up to 2 targets simultaneously and
    // split the work over multiple frames:
    // QCAR::setHint(QCAR::HINT_MAX_SIMULTANEOUS_IMAGE_TARGETS, 2);
}

ImageTargets_UpdateCallback updateCallback;

// Object to receive update callbacks from QCAR SDK
class ImageTargets_UpdateCallback : public QCAR::UpdateCallback
{
    virtual void QCAR_onUpdate(QCAR::State& /*state*/)
    {
        if (switchDataSetAsap)
        {
            switchDataSetAsap = false;

            // Get the image tracker:
            QCAR::TrackerManager& trackerManager = QCAR::TrackerManager::getInstance();
            QCAR::ImageTracker* imageTracker = static_cast<QCAR::ImageTracker*>(
                trackerManager.getTracker(QCAR::Tracker::IMAGE_TRACKER));
            if (imageTracker == 0 || dataSetStonesAndChips == 0 || dataSetTarmac == 0 ||
                imageTracker->getActiveDataSet() == 0)
            {
                LOG("Failed to switch data set.");
                return;
            }

            if (imageTracker->getActiveDataSet() == dataSetStonesAndChips)
            {
                imageTracker->deactivateDataSet(dataSetStonesAndChips);
                imageTracker->activateDataSet(dataSetTarmac);
            }
            else
            {
                imageTracker->deactivateDataSet(dataSetTarmac);
                imageTracker->activateDataSet(dataSetStonesAndChips);
            }
        }
    }
};

JNIEXPORT void JNICALL
Java_com_qualcomm_QCARSamples_ImageTargets_ImageTargets_switchDatasetAsap(JNIEnv *, jobject)
{
    switchDataSetAsap = true;
}

JNIEXPORT void JNICALL
Java_com_qualcomm_QCARSamples_ImageTargets_ImageTargets_startCamera(JNIEnv *,
                                                                         jobject)
{
    LOG("Java_com_qualcomm_QCARSamples_ImageTargets_ImageTargets_startCamera");

    // Select the camera to open, set this to QCAR::CameraDevice::CAMERA_FRONT 
    // to activate the front camera instead.
    QCAR::CameraDevice::CAMERA camera = QCAR::CameraDevice::CAMERA_DEFAULT;

    // Initialize the camera:
    if (!QCAR::CameraDevice::getInstance().init(camera))
        return;

    // Configure the video background
    configureVideoBackground();

    // Select the default mode:
    if (!QCAR::CameraDevice::getInstance().selectVideoMode(
                                QCAR::CameraDevice::MODE_DEFAULT))
        return;

    // Start the camera:
    if (!QCAR::CameraDevice::getInstance().start())
        return;

    // Uncomment to enable flash
    //if(QCAR::CameraDevice::getInstance().setFlashTorchMode(true))
    //   LOG("IMAGE TARGETS : enabled torch");

    // Uncomment to enable infinity focus mode, or any other supported focus mode
    // See CameraDevice.h for supported focus modes
    //if(QCAR::CameraDevice::getInstance().setFocusMode(QCAR::CameraDevice::FOCUS_MODE_INFINITY))
    //   LOG("IMAGE TARGETS : enabled infinity focus");

    // Start the tracker:
    QCAR::TrackerManager& trackerManager = QCAR::TrackerManager::getInstance();
    QCAR::Tracker* imageTracker = trackerManager.getTracker(QCAR::Tracker::IMAGE_TRACKER);
    if(imageTracker != 0)
        imageTracker->start();
}

Enumerator:
CAMERA_DEFAULT: Default camera device. Usually BACK.
CAMERA_BACK   : Rear facing camera.
CAMERA_FRONT  : Front facing camera.

bool QCAR::VideoBackgroundConfig::mEnabled
bool QCAR::VideoBackgroundConfig::mSynchronous
Vec2I QCAR::VideoBackgroundConfig::mPosition
Vec2I QCAR::VideoBackgroundConfig::mSize
VIDEO_BACKGROUND_REFLECTION QCAR::VideoBackgroundConfig::mReflection

MODE_DEFAULT: Default camera mode.
MODE_OPTIMIZE_SPEED: Fast camera mode.
MODE_OPTIMIZE_QUALITY: High-quality camera mode.

void
configureVideoBackground()
{
    // Get the default video mode:
    QCAR::CameraDevice& cameraDevice = QCAR::CameraDevice::getInstance();
    QCAR::VideoMode videoMode = cameraDevice.
                                getVideoMode(QCAR::CameraDevice::MODE_DEFAULT);


    // Configure the video background
    QCAR::VideoBackgroundConfig config;
    config.mEnabled = true;
    config.mSynchronous = true;
    config.mPosition.data[0] = 0.0f;
    config.mPosition.data[1] = 0.0f;

    if (isActivityInPortraitMode)
    {
        //LOG("configureVideoBackground PORTRAIT");
        config.mSize.data[0] = videoMode.mHeight
                                * (screenHeight / (float)videoMode.mWidth);
        config.mSize.data[1] = screenHeight;

        if(config.mSize.data[0] < screenWidth)
        {
            LOG("Correcting rendering background size to handle missmatch between screen and video aspect ratios.");
            config.mSize.data[0] = screenWidth;
            config.mSize.data[1] = screenWidth *
                              (videoMode.mWidth / (float)videoMode.mHeight);
        }
    }
    else
    {
        //LOG("configureVideoBackground LANDSCAPE");
        config.mSize.data[0] = screenWidth;
        config.mSize.data[1] = videoMode.mHeight
                            * (screenWidth / (float)videoMode.mWidth);

        if(config.mSize.data[1] < screenHeight)
        {
            LOG("Correcting rendering background size to handle missmatch between screen and video aspect ratios.");
            config.mSize.data[0] = screenHeight
                                * (videoMode.mWidth / (float)videoMode.mHeight);
            config.mSize.data[1] = screenHeight;
        }
    }

    LOG("Configure Video Background : Video (%d,%d), Screen (%d,%d), mSize (%d,%d)", videoMode.mWidth, videoMode.mHeight, screenWidth, screenHeight, config.mSize.data[0], config.mSize.data[1]);

    // Set the config:
    QCAR::Renderer::getInstance().setVideoBackgroundConfig(config);
}

 /**
  * NOTE: this method is synchronized because of a potential concurrent
  * access by ImageTargets::onResume() and InitQCARTask::onPostExecute().
  */
  private synchronized void updateApplicationStatus(int appStatus) {
      // Exit if there is no change in status:
      if (mAppStatus == appStatus)
          return;

      // Store new status value:
      mAppStatus = appStatus;

      // Execute application state-specific actions:
      switch (mAppStatus) {
      case APPSTATUS_INIT_APP:
          // Initialize application elements that do not rely on QCAR
          // initialization:
          initApplication();

          // Proceed to next application initialization status:
          updateApplicationStatus(APPSTATUS_INIT_QCAR);
          break;

      case APPSTATUS_INIT_QCAR:
          // Initialize QCAR SDK asynchronously to avoid blocking the
          // main (UI) thread.
          //
          // NOTE: This task instance must be created and invoked on the
          // UI thread and it can be executed only once!
          try {
              mInitQCARTask = new InitQCARTask();
              mInitQCARTask.execute();
          } catch (Exception e) {
              DebugLog.LOGE("cameraDemo", "Initializing QCAR SDK failed");
          }
          break;

      case APPSTATUS_INIT_TRACKER:
          // Initialize the ImageTracker:
          if (initTracker() > 0) {
              // Proceed to next application initialization status:
              updateApplicationStatus(APPSTATUS_INIT_APP_AR);
          }
          break;

      case APPSTATUS_INIT_APP_AR:
          // Initialize Augmented Reality-specific application elements
          // that may rely on the fact that the QCAR SDK has been
          // already initialized:
          initApplicationAR();

          // Proceed to next application initialization status:
          updateApplicationStatus(APPSTATUS_LOAD_TRACKER);
          break;

      case APPSTATUS_LOAD_TRACKER:
          // Load the tracking data set:
          //
          // NOTE: This task instance must be created and invoked on the
          // UI thread and it can be executed only once!
          try {
              mLoadTrackerTask = new LoadTrackerTask();
              mLoadTrackerTask.execute();
          } catch (Exception e) {
              DebugLog.LOGE("cameraDemo", "Loading tracking data set failed");
          }
          break;

      case APPSTATUS_INITED:
          // Hint to the virtual machine that it would be a good time to
          // run the garbage collector:
          //
          // NOTE: This is only a hint. There is no guarantee that the
          // garbage collector will actually be run.
          System.gc();

          // Native post initialization:
          onQCARInitializedNative();

          // Activate the renderer:
          mRenderer.mIsActive = true;

          // Now add the GL surface view. It is important
          // that the OpenGL ES surface view gets added
          // BEFORE the camera is started and video
          // background is configured.
          addContentView(mGlView, new LayoutParams(LayoutParams.MATCH_PARENT,
                  LayoutParams.MATCH_PARENT));

          // Sets the UILayout to be drawn in front of the camera
          // mUILayout.bringToFront();

          // Start the camera:
          updateApplicationStatus(APPSTATUS_CAMERA_RUNNING);

          break;

      case APPSTATUS_CAMERA_STOPPED:
          // Call the native function to stop the camera:
          stopCamera();
          break;

      case APPSTATUS_CAMERA_RUNNING:
          // Call the native function to start the camera:
          startCamera();

          // Hides the Loading Dialog
          // loadingDialogHandler.sendEmptyMessage(HIDE_LOADING_DIALOG);

          // Sets the layout background to transparent
          // mUILayout.setBackgroundColor(Color.TRANSPARENT);

          // Set continuous auto-focus if supported by the device,
          // otherwise default back to regular auto-focus mode.
          // This will be activated by a tap to the screen in this
          // application.
          if (!setFocusMode(FOCUS_MODE_CONTINUOUS_AUTO)) {
              mContAutofocus = false;
              setFocusMode(FOCUS_MODE_NORMAL);
          } else {
              mContAutofocus = true;
          }
          break;

      default:
          throw new RuntimeException("Invalid application state");
      }
  }

 @Override
  protected void onCreate(Bundle savedInstanceState) {
      DebugLog.LOGD("cameraDemo", "cameraDemo::onCreate");
      super.onCreate(savedInstanceState);
      // Load any sample specific textures:
      // mTextures = new Vector<Texture>();
      // loadTextures();
      // Query the QCAR initialization flags:
      mQCARFlags = getInitializationFlags();
      // Creates the GestureDetector listener for processing double tap
      // mGestureDetector = new GestureDetector(this, new GestureListener());
      // Update the application status to start initializing application:
      updateApplicationStatus(APPSTATUS_INIT_APP);
  }

 /** Configure QCAR with the desired version of OpenGL ES. */
  private int getInitializationFlags() {
      int flags = 0;

      // Query the native code:
      if (getOpenGlEsVersionNative() == 1) {
          flags = QCAR.GL_11;
      } else {
          flags = QCAR.GL_20;
      }

      return flags;
  }

// Application status constants:
private static final int APPSTATUS_UNINITED = -1;
private static final int APPSTATUS_INIT_APP = 0;
private static final int APPSTATUS_INIT_QCAR = 1;
private static final int APPSTATUS_INIT_TRACKER = 2;
private static final int APPSTATUS_INIT_APP_AR = 3;
private static final int APPSTATUS_LOAD_TRACKER = 4;
private static final int APPSTATUS_INITED = 5;
private static final int APPSTATUS_CAMERA_STOPPED = 6;
private static final int APPSTATUS_CAMERA_RUNNING = 7;

 /** Initialize application GUI elements that are not related to AR. */
  private void initApplication() {
      // Set the screen orientation:
      // NOTE: Use SCREEN_ORIENTATION_LANDSCAPE or SCREEN_ORIENTATION_PORTRAIT
      // to lock the screen orientation for this activity.
      int screenOrientation = ActivityInfo.SCREEN_ORIENTATION_SENSOR;

      // This is necessary for enabling AutoRotation in the Augmented View
      if (screenOrientation == ActivityInfo.SCREEN_ORIENTATION_SENSOR) {
          // NOTE: We use reflection here to see if the current platform
          // supports the full sensor mode (available only on Gingerbread
          // and above.
          try {
              // SCREEN_ORIENTATION_FULL_SENSOR is required to allow all
              // 4 screen rotations if API level >= 9:
              Field fullSensorField = ActivityInfo.class
                      .getField("SCREEN_ORIENTATION_FULL_SENSOR");
              screenOrientation = fullSensorField.getInt(null);
          } catch (NoSuchFieldException e) {
              // App is running on API level < 9, do nothing.
          } catch (Exception e) {
              e.printStackTrace();
          }
      }

      // Apply screen orientation
      setRequestedOrientation(screenOrientation);

      updateActivityOrientation();

      // Query display dimensions:
      storeScreenDimensions();

      // As long as this window is visible to the user, keep the device's
      // screen turned on and bright:
      getWindow().setFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON,
              WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);
  }

 /** An async task to initialize QCAR asynchronously. */
  private class InitQCARTask extends AsyncTask<Void, Integer, Boolean> {
      // Initialize with invalid value:
      private int mProgressValue = -1;

      protected Boolean doInBackground(Void... params) {
          // Prevent the onDestroy() method to overlap with initialization:
          synchronized (mShutdownLock) {
              QCAR.setInitParameters(cameraDemo.this, mQCARFlags);

              do {
                  // QCAR.init() blocks until an initialization step is
                  // complete, then it proceeds to the next step and reports
                  // progress in percents (0 ... 100%).
                  // If QCAR.init() returns -1, it indicates an error.
                  // Initialization is done when progress has reached 100%.
                  mProgressValue = QCAR.init();

                  // Publish the progress value:
                  publishProgress(mProgressValue);

                  // We check whether the task has been canceled in the
                  // meantime (by calling AsyncTask.cancel(true)).
                  // and bail out if it has, thus stopping this thread.
                  // This is necessary as the AsyncTask will run to completion
                  // regardless of the status of the component that
                  // started is.
              } while (!isCancelled() && mProgressValue >= 0
                      && mProgressValue < 100);

              return (mProgressValue > 0);
          }
      }

      protected void onProgressUpdate(Integer... values) {
          // Do something with the progress value "values[0]", e.g. update
          // splash screen, progress bar, etc.
      }

      protected void onPostExecute(Boolean result) {
          // Done initializing QCAR, proceed to next application
          // initialization status:
          if (result) {
              DebugLog.LOGD("cameraDemo",
                      "InitQCARTask::onPostExecute: QCAR "
                              + "initialization successful");

              updateApplicationStatus(APPSTATUS_INIT_TRACKER);
          } else {
              // Create dialog box for display error:
              AlertDialog dialogError = new AlertDialog.Builder(
                      cameraDemo.this).create();

              dialogError.setButton(DialogInterface.BUTTON_POSITIVE, "Close",
                      new DialogInterface.OnClickListener() {
                          public void onClick(DialogInterface dialog,
                                  int which) {
                              // Exiting application:
                              System.exit(1);
                          }
                      });

              String logMessage;

              // NOTE: Check if initialization failed because the device is
              // not supported. At this point the user should be informed
              // with a message.
              if (mProgressValue == QCAR.INIT_DEVICE_NOT_SUPPORTED) {
                  logMessage = "Failed to initialize QCAR because this "
                          + "device is not supported.";
              } else {
                  logMessage = "Failed to initialize QCAR.";
              }

              // Log error:
              DebugLog.LOGE("cameraDemo", "InitQCARTask::onPostExecute: "
                      + logMessage + " Exiting.");

              // Show dialog box with error message:
              dialogError.setMessage(logMessage);
              dialogError.show();
          }
      }
  }
  

JNIEXPORT int JNICALL
Java_com_qualcomm_QCARSamples_ImageTargets_ImageTargets_initTracker(JNIEnv *, jobject)
{
    LOG("Java_com_qualcomm_QCARSamples_ImageTargets_ImageTargets_initTracker");

    // Initialize the image tracker:
    QCAR::TrackerManager& trackerManager = QCAR::TrackerManager::getInstance();
    QCAR::Tracker* tracker = trackerManager.initTracker(QCAR::Tracker::IMAGE_TRACKER);
    if (tracker == NULL)
    {
        LOG("Failed to initialize ImageTracker.");
        return 0;
    }

    LOG("Successfully initialized ImageTracker.");
    return 1;
}

Instance：An instanceis an object created from a class. The class describes the (behavior and information)structure of the instance, while the current state of the instance is defined by the operations performed on the instance.

 /**
  * NOTE: this method is synchronized because of a potential concurrent
  * access by ImageTargets::onResume() and InitQCARTask::onPostExecute().
  */
  private synchronized void updateApplicationStatus(int appStatus) {
      // Exit if there is no change in status:
      if (mAppStatus == appStatus)
          return;

      // Store new status value:
      mAppStatus = appStatus;

      // Execute application state-specific actions:
      switch (mAppStatus) {
      case APPSTATUS_INIT_APP:
          // Initialize application elements that do not rely on QCAR
          // initialization:
          initApplication();

          // Proceed to next application initialization status:
          updateApplicationStatus(APPSTATUS_INIT_QCAR);
          break;

      case APPSTATUS_INIT_QCAR:
          // Initialize QCAR SDK asynchronously to avoid blocking the
          // main (UI) thread.
          //
          // NOTE: This task instance must be created and invoked on the
          // UI thread and it can be executed only once!
          try {
              mInitQCARTask = new InitQCARTask();
              mInitQCARTask.execute();
          } catch (Exception e) {
              DebugLog.LOGE("cameraDemo", "Initializing QCAR SDK failed");
          }
          break;

      case APPSTATUS_INIT_TRACKER:
          // Initialize the ImageTracker:
          if (initTracker() > 0) {
              // Proceed to next application initialization status:
              updateApplicationStatus(APPSTATUS_INIT_APP_AR);
          }
          break;

      case APPSTATUS_INIT_APP_AR:
          // Initialize Augmented Reality-specific application elements
          // that may rely on the fact that the QCAR SDK has been
          // already initialized:
          initApplicationAR();

          // Proceed to next application initialization status:
          updateApplicationStatus(APPSTATUS_LOAD_TRACKER);
          break;

      case APPSTATUS_LOAD_TRACKER:
          // Load the tracking data set:
          //
          // NOTE: This task instance must be created and invoked on the
          // UI thread and it can be executed only once!
          try {
              mLoadTrackerTask = new LoadTrackerTask();
              mLoadTrackerTask.execute();
          } catch (Exception e) {
              DebugLog.LOGE("cameraDemo", "Loading tracking data set failed");
          }
          break;

      case APPSTATUS_INITED:
          // Hint to the virtual machine that it would be a good time to
          // run the garbage collector:
          //
          // NOTE: This is only a hint. There is no guarantee that the
          // garbage collector will actually be run.
          System.gc();

          // Native post initialization:
          onQCARInitializedNative();

          // Activate the renderer:
          mRenderer.mIsActive = true;

          // Now add the GL surface view. It is important
          // that the OpenGL ES surface view gets added
          // BEFORE the camera is started and video
          // background is configured.
          addContentView(mGlView, new LayoutParams(LayoutParams.MATCH_PARENT,
                  LayoutParams.MATCH_PARENT));

          // Sets the UILayout to be drawn in front of the camera
          // mUILayout.bringToFront();

          // Start the camera:
          updateApplicationStatus(APPSTATUS_CAMERA_RUNNING);

          break;

      case APPSTATUS_CAMERA_STOPPED:
          // Call the native function to stop the camera:
          stopCamera();
          break;

      case APPSTATUS_CAMERA_RUNNING:
          // Call the native function to start the camera:
          startCamera();

          // Hides the Loading Dialog
          // loadingDialogHandler.sendEmptyMessage(HIDE_LOADING_DIALOG);

          // Sets the layout background to transparent
          // mUILayout.setBackgroundColor(Color.TRANSPARENT);

          // Set continuous auto-focus if supported by the device,
          // otherwise default back to regular auto-focus mode.
          // This will be activated by a tap to the screen in this
          // application.
          if (!setFocusMode(FOCUS_MODE_CONTINUOUS_AUTO)) {
              mContAutofocus = false;
              setFocusMode(FOCUS_MODE_NORMAL);
          } else {
              mContAutofocus = true;
          }
          break;

      default:
          throw new RuntimeException("Invalid application state");
      }
  }

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.example.vuforiacamera"
    android:versionCode="1"
    android:versionName="1.0" >

    <uses-sdk
        android:minSdkVersion="15"
        android:targetSdkVersion="15" />
    <!-- Add permission of camera -->
    <uses-feature android:name="android.hardware.camera" />
    <uses-permission android:name="android.permission.CAMERA" />


    <application
        android:allowBackup="true"
        android:icon="@drawable/ic_launcher"
        android:label="@string/app_name"
        android:theme="@style/AppTheme" >
        <activity
            android:name="com.example.vuforiacamera.MainActivity"
            android:configChanges="orientation|keyboardHidden"
            android:label="@string/app_name" >
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />

                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>

    </application>

</manifest>

/*==============================================================================
            Copyright (c) 2010-2012 QUALCOMM Austria Research Center GmbH.
            All Rights Reserved.
            Qualcomm Confidential and Proprietary
==============================================================================*/

package com.qualcomm.QCARSamples.ImageTargets;

import com.qualcomm.QCAR.QCAR;

import javax.microedition.khronos.egl.EGL10;
import javax.microedition.khronos.egl.EGLConfig;
import javax.microedition.khronos.egl.EGLContext;
import javax.microedition.khronos.egl.EGLDisplay;

import android.content.Context;
import android.graphics.PixelFormat;
import android.opengl.GLSurfaceView;


/** QCARSampleGLView is a support class for the QCAR samples applications.
 *
 *  Responsible for setting up and configuring the OpenGL surface view.
 *
 * */
public class QCARSampleGLView extends GLSurfaceView
{
    private static boolean mUseOpenGLES2 = true;

    /** Constructor. */
    public QCARSampleGLView(Context context)
    {
        super(context);
    }


    /** Initialization. */
    public void init(int flags, boolean translucent, int depth, int stencil)
    {
        // By default GLSurfaceView tries to find a surface that is as close
        // as possible to a 16-bit RGB frame buffer with a 16-bit depth buffer.
        // This function can override the default values and set custom values.

        // Extract OpenGL ES version from flags
        mUseOpenGLES2 = (flags & QCAR.GL_20) != 0;

        // By default, GLSurfaceView() creates a RGB_565 opaque surface.
        // If we want a translucent one, we should change the surface's
        // format here, using PixelFormat.TRANSLUCENT for GL Surfaces
        // is interpreted as any 32-bit surface with alpha by SurfaceFlinger.

        DebugLog.LOGI("Using OpenGL ES " + (mUseOpenGLES2 ? "2.0" : "1.x"));
        DebugLog.LOGI("Using " + (translucent ? "translucent" : "opaque") +
            " GLView, depth buffer size: " + depth + ", stencil size: " +
            stencil);

        // If required set translucent format to allow camera image to
        // show through in the background
        if (translucent)
        {
            this.getHolder().setFormat(PixelFormat.TRANSLUCENT);
        }

        // Setup the context factory for 1.x / 2.0 rendering
        setEGLContextFactory(new ContextFactory());

        // We need to choose an EGLConfig that matches the format of
        // our surface exactly. This is going to be done in our
        // custom config chooser. See ConfigChooser class definition
        // below.
        setEGLConfigChooser( translucent ?
                             new ConfigChooser(8, 8, 8, 8, depth, stencil) :
                             new ConfigChooser(5, 6, 5, 0, depth, stencil) );
    }


    /** Creates OpenGL contexts. */
    private static class ContextFactory implements
        GLSurfaceView.EGLContextFactory
    {
        private static int EGL_CONTEXT_CLIENT_VERSION = 0x3098;
        public EGLContext createContext(EGL10 egl, EGLDisplay display,
            EGLConfig eglConfig)
        {
            EGLContext context;
            if (mUseOpenGLES2)
            {
                DebugLog.LOGI("Creating OpenGL ES 2.0 context");
                checkEglError("Before eglCreateContext", egl);
                int[] attrib_list_gl20 = {EGL_CONTEXT_CLIENT_VERSION, 2,
                    EGL10.EGL_NONE};
                context = egl.eglCreateContext(display, eglConfig,
                    EGL10.EGL_NO_CONTEXT, attrib_list_gl20);
            }
            else
            {
                DebugLog.LOGI("Creating OpenGL ES 1.x context");
                checkEglError("Before eglCreateContext", egl);
                int[] attrib_list_gl1x = {EGL_CONTEXT_CLIENT_VERSION, 1,
                    EGL10.EGL_NONE};
                context = egl.eglCreateContext(display, eglConfig,
                    EGL10.EGL_NO_CONTEXT, attrib_list_gl1x);
            }

            checkEglError("After eglCreateContext", egl);
            return context;
        }

        public void destroyContext(EGL10 egl, EGLDisplay display,
            EGLContext context)
        {
            egl.eglDestroyContext(display, context);
        }
    }


    /** Checks the OpenGL error. */
    private static void checkEglError(String prompt, EGL10 egl)
    {
        int error;
        while ((error = egl.eglGetError()) != EGL10.EGL_SUCCESS)
        {
            DebugLog.LOGE(String.format("%s: EGL error: 0x%x", prompt, error));
        }
    }


    /** The config chooser. */
    private static class ConfigChooser implements GLSurfaceView.EGLConfigChooser
    {
        public ConfigChooser(int r, int g, int b, int a, int depth, int stencil)
        {
            mRedSize = r;
            mGreenSize = g;
            mBlueSize = b;
            mAlphaSize = a;
            mDepthSize = depth;
            mStencilSize = stencil;
        }


        private EGLConfig getMatchingConfig(EGL10 egl, EGLDisplay display,
            int[] configAttribs)
        {
            // Get the number of minimally matching EGL configurations
            int[] num_config = new int[1];
            egl.eglChooseConfig(display, configAttribs, null, 0, num_config);

            int numConfigs = num_config[0];
            if (numConfigs <= 0)
                throw new IllegalArgumentException("No matching EGL configs");

            // Allocate then read the array of minimally matching EGL configs
            EGLConfig[] configs = new EGLConfig[numConfigs];
            egl.eglChooseConfig(display, configAttribs, configs, numConfigs,
                num_config);

            // Now return the "best" one
            return chooseConfig(egl, display, configs);
        }


        public EGLConfig chooseConfig(EGL10 egl, EGLDisplay display)
        {
            if (mUseOpenGLES2)
            {
                // This EGL config specification is used to specify 2.0
                // rendering. We use a minimum size of 4 bits for
                // red/green/blue, but will perform actual matching in
                // chooseConfig() below.
                final int EGL_OPENGL_ES2_BIT = 0x0004;
                final int[] s_configAttribs_gl20 =
                {
                    EGL10.EGL_RED_SIZE, 4,
                    EGL10.EGL_GREEN_SIZE, 4,
                    EGL10.EGL_BLUE_SIZE, 4,
                    EGL10.EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
                    EGL10.EGL_NONE
                };

                return getMatchingConfig(egl, display, s_configAttribs_gl20);
            }
            else
            {
                final int EGL_OPENGL_ES1X_BIT = 0x0001;
                final int[] s_configAttribs_gl1x =
                {
                    EGL10.EGL_RED_SIZE, 5,
                    EGL10.EGL_GREEN_SIZE, 6,
                    EGL10.EGL_BLUE_SIZE, 5,
                    EGL10.EGL_RENDERABLE_TYPE, EGL_OPENGL_ES1X_BIT,
                    EGL10.EGL_NONE
                };

                return getMatchingConfig(egl, display, s_configAttribs_gl1x);
            }
        }


        public EGLConfig chooseConfig(
            EGL10 egl, EGLDisplay display, EGLConfig[] configs)
        {
            for(EGLConfig config : configs)
            {
                int d = findConfigAttrib(egl, display, config,
                        EGL10.EGL_DEPTH_SIZE, 0);
                int s = findConfigAttrib(egl, display, config,
                        EGL10.EGL_STENCIL_SIZE, 0);

                // We need at least mDepthSize and mStencilSize bits
                if (d < mDepthSize || s < mStencilSize)
                    continue;

                // We want an *exact* match for red/green/blue/alpha
                int r = findConfigAttrib(egl, display, config,
                        EGL10.EGL_RED_SIZE, 0);
                int g = findConfigAttrib(egl, display, config,
                            EGL10.EGL_GREEN_SIZE, 0);
                int b = findConfigAttrib(egl, display, config,
                            EGL10.EGL_BLUE_SIZE, 0);
                int a = findConfigAttrib(egl, display, config,
                        EGL10.EGL_ALPHA_SIZE, 0);

                if (r == mRedSize &&
                    g == mGreenSize &&
                    b == mBlueSize &&
                    a == mAlphaSize)
                    return config;
            }

            return null;
        }


        private int findConfigAttrib(
            EGL10 egl, EGLDisplay display, EGLConfig config, int attribute,
            int defaultValue)
        {

            if (egl.eglGetConfigAttrib(display, config, attribute, mValue))
                return mValue[0];

            return defaultValue;
        }


        // Subclasses can adjust these values:
        protected int mRedSize;
        protected int mGreenSize;
        protected int mBlueSize;
        protected int mAlphaSize;
        protected int mDepthSize;
        protected int mStencilSize;
        private int[] mValue = new int[1];
    }
}

    private void initApplicationAR()
    {
        // Do application initialization in native code (e.g. registering
        // callbacks, etc.):
        initApplicationNative(mScreenWidth, mScreenHeight);

        // Create OpenGL ES view:
        int depthSize = 16;
        int stencilSize = 0;
        boolean translucent = QCAR.requiresAlpha();

        mGlView = new QCARSampleGLView(this);
        mGlView.init(mQCARFlags, translucent, depthSize, stencilSize);

        mRenderer = new ImageTargetsRenderer();
        mRenderer.mActivity = this;
        mGlView.setRenderer(mRenderer);

        LayoutInflater inflater = LayoutInflater.from(this);
        mUILayout = (RelativeLayout) inflater.inflate(R.layout.camera_overlay,
                null, false);

        mUILayout.setVisibility(View.VISIBLE);
        mUILayout.setBackgroundColor(Color.BLACK);

        // Gets a reference to the loading dialog
        mLoadingDialogContainer = mUILayout.findViewById(R.id.loading_indicator);

        // Shows the loading indicator at start
        loadingDialogHandler.sendEmptyMessage(SHOW_LOADING_DIALOG);

        // Adds the inflated layout to the view
        addContentView(mUILayout, new LayoutParams(LayoutParams.MATCH_PARENT,
                LayoutParams.MATCH_PARENT));
    }

/*==============================================================================
            Copyright (c) 2010-2012 QUALCOMM Austria Research Center GmbH.
            All Rights Reserved.
            Qualcomm Confidential and Proprietary

@file
    ImageTargetsRenderer.java

@brief
    Sample for ImageTargets

==============================================================================*/


package com.qualcomm.QCARSamples.ImageTargets;

import javax.microedition.khronos.egl.EGLConfig;
import javax.microedition.khronos.opengles.GL10;

import android.opengl.GLSurfaceView;

import com.qualcomm.QCAR.QCAR;


/** The renderer class for the ImageTargets sample. */
public class ImageTargetsRenderer implements GLSurfaceView.Renderer
{
    public boolean mIsActive = false;

    /** Reference to main activity **/
    public ImageTargets mActivity;

    /** Native function for initializing the renderer. */
    public native void initRendering();

    /** Native function to update the renderer. */
    public native void updateRendering(int width, int height);


    /** Called when the surface is created or recreated. */
    public void onSurfaceCreated(GL10 gl, EGLConfig config)
    {
        DebugLog.LOGD("GLRenderer::onSurfaceCreated");

        // Call native function to initialize rendering:
        initRendering();

        // Call QCAR function to (re)initialize rendering after first use
        // or after OpenGL ES context was lost (e.g. after onPause/onResume):
        QCAR.onSurfaceCreated();
    }


    /** Called when the surface changed size. */
    public void onSurfaceChanged(GL10 gl, int width, int height)
    {
        DebugLog.LOGD("GLRenderer::onSurfaceChanged");

        // Call native function to update rendering when render surface
        // parameters have changed:
        updateRendering(width, height);

        // Call QCAR function to handle render surface size changes:
        QCAR.onSurfaceChanged(width, height);
    }


    /** The native render function. */
    public native void renderFrame();


    /** Called to draw the current frame. */
    public void onDrawFrame(GL10 gl)
    {
        if (!mIsActive)
            return;

        // Update render view (projection matrix and viewport) if needed:
        mActivity.updateRenderView();

        // Call our native function to render content
        renderFrame();
    }
}

'''
Created on 2013/2/3

@author: CYChiang
'''
import Shape
if __name__ == '__main__':
    a = Shape.Point()
    b = Shape.Point(3, 4)
    print("a = Shape.Point")
    print("repr(a) = ", repr(a))
    print("b = Shape.Point(3, 4)")
    print("repr(b) = ", repr(b))
    print("str(b) = ", str(b))
    print("b.distance_from_origin = ", b.distance_from_origin())
    b.x = -19
    print("b=-19, str(b) = ", str(b))
    if a == b:
        print("Point a equal b")
    if a != b:
        print("Point a not equal to b")

'''
Created on 2013/2/3

@author: CYChiang
'''
import math

class Point:
    def __init__(self, x=0, y=0):
        self.x = x
        self.y = y
    def distance_from_origin(self):
        return math.hypot(self.x, self.y)
    def __eq__(self, other):
        return self.x == other.x and self.y == other.y
    def __repr__(self):
        return "Point({0.x!r}, {0.y!r})".format(self)
    def __str__(self):
        return "({0.x!r}, {0.y!r})".format(self)

class Circle(Point):
    radius = 0
    def __init__(self, radius=0, x=0, y=0):
        #super().__init__(x, y)
        #super(Circle, self).__init__(x, y)
        Point.__init__(self, x, y)
        self.radius = radius
    def edge_distance_from_origin(self):
        return abs (self.distance_from_origin - self.radius)
    def area(self):
        return math.pi * (self.radius ** 2)
    def circumference(self):
        return 2 * math.pi * self.radius
    def __eq__(self, other):
        return self.radius == other.radius and super().__eq__(other)
    def __repr__(self):
        return "Circle({0.radius!r}, {0.x!r}, {0.y!r})".format(self)
    def __str__(self):
        return repr(self)

'''
Created on 2013/2/3

@author: CYChiang
'''
import math

class Point(object):
    def __init__(self, x=0, y=0):
        self.x = x
        self.y = y
    def distance_from_origin(self):
        return math.hypot(self.x, self.y)
    def __eq__(self, other):
        return self.x == other.x and self.y == other.y
    def __repr__(self):
        return "Point({0.x!r}, {0.y!r})".format(self)
    def __str__(self):
        return "({0.x!r}, {0.y!r})".format(self)
    @property
    def x(self):
        return self.__x
    @property
    def y(self):
        return self.__y
    @x.setter
    def x(self, x):
        assert x > 0, "must be nonzero and non-negative"
        self.__x = x
    @y.setter
    def y(self, y):
        assert y > 0, "must be nonzero and non-negative"
        self.__y=y


class Circle(Point):
    radius = 0
    def __init__(self, radius=0, x=0, y=0):
        #super().__init__(x, y)
        #super(Circle, self).__init__(x, y)
        Point.__init__(self, x, y)
        self.radius = radius
    @property
    def edge_distance_from_origin(self):
        return abs(self.distance_from_origin - self.radius)
    @property
    def area(self):
        return math.pi * (self.radius ** 2)
    def circumference(self):
        return 2 * math.pi * self.radius
    def __eq__(self, other):
        return self.radius == other.radius and super().__eq__(other)
    def __repr__(self):
        return "Circle({0.radius!r}, {0.x!r}, {0.y!r})".format(self)
    def __str__(self):
        return repr(self)
    @property
    def radius(self):
        return self.__radius
    @radius.setter
    def radius(self, radius):
        assert radius > 0, "must be nonzero and non-negative"
        self.__radius = radius