1. Download our Official Android App: Forums for Android!

How To Crop Bitmaps For To Perform Motion Detection

Discussion in 'Android Development' started by Kindall Ush, Aug 23, 2017.

  1. Kindall Ush

    Kindall Ush Lurker
    Thread Starter
    Rank:
    None
    Points:
    5
    Posts:
    1
    Joined:
    Aug 23, 2017

    Aug 23, 2017
    1
    0
    5
    Trying to make a motion detection app based on this project. The intention is to make the app take pictures when motion is detected by comparing two images. Up to this part, the app is working fine.
    Requirement:
    To specify area of detection by a custom view. So that, the pictures will be captured only if a motion is detected inside the defined area by calculating the detection area.
    What I have done so far:
    Created a movable custom view, like a crop view of which the dimensions (Rect) are saved in the preference each time when the view is moved.
    What is not working:
    The motion detection from inside the custom view is not working. I believe that the bitmaps must be cropped according to the size of the custom view to do the comparison. In the detection thread I tried setting the width and height from the preference like :
    Code (Text):
    1.  private int width = Prefe.DetectionArea.width();
    2. private int height = Prefe.DetectionArea.height();
    But it didn't work. Please help me by explaining how this could be achieved and what changes should be made in the code so that the motion detection will happen according to the size of the custom view. Any help is appreciated.

    Source: https://goo.gl/3m9mRU

    MotionDetectionActivity.java

    Code (Text):
    1. public class MotionDetectionActivity extends SensorsActivity {
    2.  
    3.     private static final String TAG = "MotionDetectionActivity";
    4.     private static long mReferenceTime = 0;
    5.     private static IMotionDetection detector = null;
    6.     public static MediaPlayer song;
    7.     public static Vibrator mVibrator;
    8.  
    9.     private static SurfaceView preview = null;
    10.     private static SurfaceHolder previewHolder = null;
    11.     private static Camera camera = null;
    12.     private static boolean inPreview = false;
    13.     private static AreaDetectorView mDetector;
    14.     private static FrameLayout layoutDetectorArea;
    15.     static FrameLayout layoutMain;
    16.     static View mView;
    17.     private static volatile AtomicBoolean processing = new AtomicBoolean(false);
    18.  
    19.     /**
    20.      * {@inheritDoc}
    21.      */
    22.     @Override
    23.     public void onCreate(Bundle savedInstanceState) {
    24.         super.onCreate(savedInstanceState);
    25.         getWindow().addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);
    26.         setContentView(R.layout.main);
    27.  
    28.         mVibrator = (Vibrator)this.getSystemService(VIBRATOR_SERVICE);
    29.         layoutMain=(FrameLayout)findViewById(R.id.layoutMain);
    30.         preview = (SurfaceView) findViewById(R.id.preview);
    31.         previewHolder = preview.getHolder();
    32.         previewHolder.addCallback(surfaceCallback);
    33.         previewHolder.setType(SurfaceHolder.SURFACE_TYPE_PUSH_BUFFERS);
    34.         mView=layoutMain;
    35.         mDetector= (AreaDetectorView) findViewById(R.id.viewDetector);
    36.         layoutDetectorArea=(FrameLayout) findViewById(R.id.layoutDetectArea);
    37.  
    38.         ToggleButton toggle = (ToggleButton) findViewById(R.id.simpleToggleButton);
    39.         toggle.setOnCheckedChangeListener(new CompoundButton.OnCheckedChangeListener() {
    40.             public void onCheckedChanged(CompoundButton buttonView, boolean isChecked) {
    41.                 if (isChecked) {
    42.                     // The toggle is enabled
    43.  
    44.  
    45.                 } else {
    46.                     // The toggle is disabled
    47.                 }
    48.             }
    49.         });
    50.  
    51.  
    52.         if (Preferences.USE_RGB) {
    53.             detector = new RgbMotionDetection();
    54.         } else if (Preferences.USE_LUMA) {
    55.             detector = new LumaMotionDetection();
    56.         } else {
    57.             // Using State based (aggregate map)
    58.             detector = new AggregateLumaMotionDetection();
    59.         }
    60.     }
    61.  
    62.     /**
    63.      * {@inheritDoc}
    64.      */
    65.     @Override
    66.     public void onConfigurationChanged(Configuration newConfig) {
    67.         super.onConfigurationChanged(newConfig);
    68.     }
    69.  
    70.     /**dd:
    71.      * Song play # 1
    72.      * Camera callback
    73.      *
    74.      * {@inheritDoc}
    75.      */
    76.     @Override
    77.     public void onPause() {
    78.         super.onPause();
    79.         if(song!=null && song.isPlaying())
    80.         {
    81.             song.stop();}
    82.  
    83.         camera.setPreviewCallback(null);
    84.         if (inPreview) camera.stopPreview();
    85.         inPreview = false;
    86.         camera.release();
    87.         camera = null;
    88.     }
    89.  
    90.     /**
    91.      * {@inheritDoc}
    92.      */
    93.     @Override
    94.     public void onResume() {
    95.         super.onResume();
    96.  
    97.         camera = Camera.open();
    98.     }
    99.  
    100.     private PreviewCallback previewCallback = new PreviewCallback() {
    101.  
    102.         /**
    103.          * {@inheritDoc}
    104.          */
    105.         @Override
    106.         public void onPreviewFrame(byte[] data, Camera cam) {
    107.             if (data == null) return;
    108.             Camera.Size size = cam.getParameters().getPreviewSize();
    109.             if (size == null) return;
    110.  
    111.             if (!GlobalData.isPhoneInMotion()) {
    112.                 DetectionThread thread = new DetectionThread(data, size.width, size.height);
    113.                 thread.start();
    114.             }
    115.         }
    116.     };
    117.  
    118.     private SurfaceHolder.Callback surfaceCallback = new SurfaceHolder.Callback() {
    119.  
    120.         /**
    121.          * {@inheritDoc}
    122.          */
    123.         @Override
    124.         public void surfaceCreated(SurfaceHolder holder) {
    125.             try {
    126.  
    127.                 camera.setPreviewDisplay(previewHolder);
    128.                 camera.setPreviewCallback(previewCallback);
    129.             } catch (Throwable t) {
    130.                 Log.e("Prek", "Exception in setPreviewDisplay()", t);
    131.             }
    132.         }
    133.  
    134.         /**
    135.          * {@inheritDoc}
    136.          */
    137.         @Override
    138.         public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) {
    139.             if(camera != null) {
    140.                 Camera.Parameters parameters = camera.getParameters();
    141.                 parameters.setFocusMode(Camera.Parameters.FOCUS_MODE_CONTINUOUS_PICTURE);
    142.                 Camera.Size size = getBestPreviewSize(width, height, parameters);
    143.                 if (size != null) {
    144.                     parameters.setPreviewSize(size.width, size.height);
    145.                     Log.d(TAG, "Using width=" + size.width + " height=" + size.height);
    146.                 }
    147.                 camera.setParameters(parameters);
    148.                 camera.startPreview();
    149.                 inPreview = true;
    150.             }
    151.             //AreaDetectorView.InitDetectionArea();
    152.         }
    153.  
    154.         /**
    155.          * {@inheritDoc}
    156.          */
    157.         @Override
    158.         public void surfaceDestroyed(SurfaceHolder holder) {
    159.             // Ignore
    160.         }
    161.     };
    162.  
    163.     private static Camera.Size getBestPreviewSize(int width, int height, Camera.Parameters parameters) {
    164.         Camera.Size result = null;
    165.  
    166.         for (Camera.Size size : parameters.getSupportedPreviewSizes()) {
    167.             if (size.width <= width && size.height <= height) {
    168.                 if (result == null) {
    169.                     result = size;
    170.                 } else {
    171.                     int resultArea = result.width * result.height;
    172.                     int newArea = size.width * size.height;
    173.  
    174.                     if (newArea > resultArea) result = size;
    175.                 }
    176.             }
    177.         }
    178.  
    179.         return result;
    180.     }
    181.  
    182.     //***************Detection Class******************//
    183.  
    184.     private final class DetectionThread extends Thread {
    185.  
    186.         private byte[] data;
    187.         private int width;
    188.         private int height;
    189.  
    190.         public DetectionThread(byte[] data, int width, int height) {
    191.             this.data = data;
    192.             this.width = width;
    193.             this.height = height;
    194.         }
    195.  
    196.         /**
    197.          * {@inheritDoc}
    198.          */
    199.         @Override
    200.         public void run() {
    201.             if (!processing.compareAndSet(false, true)) return;
    202.  
    203.             // Log.d(TAG, "BEGIN PROCESSING...");
    204.             try {
    205.                 // Previous frame
    206.                 int[] pre = null;
    207.                 if (Preferences.SAVE_PREVIOUS) pre = detector.getPrevious();
    208.  
    209.                 // Current frame (with changes)
    210.                 // long bConversion = System.currentTimeMillis();
    211.                 int[] img = null;
    212.                 if (Preferences.USE_RGB) {
    213.                     img = ImageProcessing.decodeYUV420SPtoRGB(data, width, height);
    214.                 } else {
    215.                     img = ImageProcessing.decodeYUV420SPtoLuma(data, width, height);
    216.                 }
    217.  
    218.  
    219.                 // Current frame (without changes)
    220.                 int[] org = null;
    221.                 if (Preferences.SAVE_ORIGINAL && img != null) org = img.clone();
    222.  
    223.                 if (img != null && detector.detect(img, width, height)) {
    224.  
    225.  
    226.                     // The delay is necessary to avoid taking a picture while in
    227.                     // the
    228.                     // middle of taking another. This problem can causes some
    229.                     // phones
    230.                     // to reboot.
    231.                     long now = System.currentTimeMillis();
    232.                     if (now > (mReferenceTime + Preferences.PICTURE_DELAY)) {
    233.                         mReferenceTime = now;
    234.  
    235.                         //mVibrator.vibrate(10);
    236.  
    237.                         Bitmap previous = null;
    238.                         if (Preferences.SAVE_PREVIOUS && pre != null) {
    239.                             if (Preferences.USE_RGB) previous = ImageProcessing.rgbToBitmap(pre, width, height);
    240.                             else previous = ImageProcessing.lumaToGreyscale(pre, width, height);
    241.                         }
    242.  
    243.                         Bitmap original = null;
    244.                         if (Preferences.SAVE_ORIGINAL && org != null) {
    245.                             if (Preferences.USE_RGB) original = ImageProcessing.rgbToBitmap(org, width, height);
    246.                             else original = ImageProcessing.lumaToGreyscale(org, width, height);
    247.                         }
    248.  
    249.                         Bitmap bitmap = null;
    250.                         if (Preferences.SAVE_CHANGES) {
    251.                             if (Preferences.USE_RGB) bitmap = ImageProcessing.rgbToBitmap(img, width, height);
    252.                             else bitmap = ImageProcessing.lumaToGreyscale(img, width, height);
    253.                         }
    254.                         Log.i(TAG, "Saving.. previous=" + previous + " original=" + original + " bitmap=" + bitmap);
    255.                         Looper.prepare();
    256.                         new SavePhotoTask().execute(previous, original, bitmap);
    257.                     } else {
    258.                         Log.i(TAG, "Not taking picture because not enough time has passed since the creation of the Surface");
    259.                     }
    260.                 }
    261.             } catch (Exception e) {
    262.                 e.printStackTrace();
    263.             } finally {
    264.                 processing.set(false);
    265.             }
    266.             // Log.d(TAG, "END PROCESSING...");
    267.             processing.set(false);
    268.         }
    269.     };
    270.  
    271.     private static final class SavePhotoTask extends AsyncTask<Bitmap, Integer, Integer> {
    272.  
    273.         /**
    274.          * {@inheritDoc}
    275.          */
    276.         @Override
    277.         protected Integer doInBackground(Bitmap... data) {
    278.             for (int i = 0; i < data.length; i++) {
    279.                 Bitmap bitmap = data[i];
    280.                 String name = String.valueOf(System.currentTimeMillis());
    281.                 if (bitmap != null) save(name, bitmap);
    282.             }
    283.             return 1;
    284.         }
    285.  
    286.         private void save(String name, Bitmap bitmap) {
    287.             File photo = new File(Environment.getExternalStorageDirectory(), name + ".jpg");
    288.             if (photo.exists()) photo.delete();
    289.  
    290.             try {
    291.                 FileOutputStream fos = new FileOutputStream(photo.getPath());
    292.                 bitmap.compress(Bitmap.CompressFormat.JPEG, 100, fos);
    293.                 fos.close();
    294.             } catch (java.io.IOException e) {
    295.                 Log.e("PictureDemo", "Exception in photoCallback", e);
    296.             }
    297.         }
    298.     }
    299.     }
    AreaDetectorView.java


    Code (Text):
    1. public class  AreaDetectorView extends LinearLayout {
    2.  
    3.     public static int Width;
    4.     public static int Height;
    5.  
    6.     private static Paint BoxPaint = null;
    7.     private static Paint TextPaint = null;
    8.     private static Paint ArrowPaint = null;
    9.     private static Path mPath = null;
    10.     private static Rect mRect = null;
    11.     private static int lastX, lastY = 0;
    12.     private static boolean mBoxTouched = false;
    13.     private static boolean mArrowTouched = false;
    14.     private static Context mContext;
    15.     private static int ArrowWidth = 0;
    16.     private static Paint BoxPaint2 = null;
    17.  
    18.     public AreaDetectorView(Context context) {
    19.         super(context);
    20.         mContext = context;
    21.     }
    22.     //attrs was not there
    23.     public AreaDetectorView(Context context, AttributeSet attrs) {
    24.         super(context,attrs);
    25.         mContext = context;
    26.         // TODO Auto-generated constructor stub
    27.         if (!this.getRootView().isInEditMode()) {
    28.             ArrowWidth =GetDisplayPixel(context, 30);
    29.         }
    30.  
    31.         //InitDetectionArea();
    32.  
    33.         InitMemberVariables();
    34.         setWillNotDraw(false);
    35.     }
    36.     public static int GetDisplayPixel(Context paramContext, int paramInt)
    37.     {
    38.         return (int)(paramInt * paramContext.getResources().getDisplayMetrics().density + 0.5F);
    39.     }
    40.  
    41.     public static void InitMemberVariables() {
    42.         if (BoxPaint == null) {
    43.             BoxPaint = new Paint();
    44.             BoxPaint.setAntiAlias(true);
    45.             BoxPaint.setStrokeWidth(2.0f);
    46.             //BoxPaint.setStyle(Style.STROKE);
    47.             BoxPaint.setStyle(Style.FILL_AND_STROKE);
    48.             BoxPaint.setColor(ContextCompat.getColor(mContext, R.color.bwff_60));
    49.         }
    50.         if (ArrowPaint == null) {
    51.             ArrowPaint = new Paint();
    52.             ArrowPaint.setAntiAlias(true);
    53.             ArrowPaint.setColor(ContextCompat.getColor(mContext,R.color.redDD));
    54.             ArrowPaint.setStyle(Style.FILL_AND_STROKE);
    55.         }
    56.         if (TextPaint == null) {
    57.             TextPaint = new Paint();
    58.             TextPaint.setColor(ContextCompat.getColor(mContext,R.color.yellowL));
    59.             TextPaint.setTextSize(16);
    60.             //txtPaint.setTypeface(lcd);
    61.             TextPaint.setStyle(Style.FILL_AND_STROKE);
    62.         }
    63.         if (mPath == null) {
    64.             mPath = new Path();
    65.         } else {
    66.             mPath.reset();
    67.         }
    68.         if (mRect == null) {
    69.             mRect = new Rect();
    70.         }
    71.  
    72.         if (BoxPaint2 == null) {
    73.             BoxPaint2 = new Paint();
    74.             BoxPaint2.setAntiAlias(true);
    75.             BoxPaint2.setStrokeWidth(2.0f);
    76.             //BoxPaint.setStyle(Style.STROKE);
    77.             BoxPaint2.setStyle(Style.STROKE);
    78.             BoxPaint2.setColor(ContextCompat.getColor(mContext,R.color.bwff_9e));
    79.         }
    80.  
    81.     }
    82.  
    83.     public static void InitDetectionArea() {
    84.         try {
    85.             int w = Prefe.DetectionArea.width();
    86.             int h = Prefe.DetectionArea.height();
    87.             int x = Prefe.DetectionArea.left;
    88.             int y = Prefe.DetectionArea.top;
    89.  
    90.             // ver 2.6.0
    91.             if (Prefe.DetectionArea.left == 1
    92.                     && Prefe.DetectionArea.top == 1
    93.                     && Prefe.DetectionArea.right == 1
    94.                     && Prefe.DetectionArea.bottom == 1) {
    95.  
    96.                 w = Prefe.DisplayWidth / 4;
    97.                 h = Prefe.DisplayHeight / 3;
    98.  
    99.                 // ver 2.5.9
    100.                 w = Width / 4;
    101.                 h = Height / 3;
    102.  
    103.                 Prefe.DetectorWidth = w;    //UtilGeneralHelper.GetDisplayPixel(this, 100);
    104.                 Prefe.DetectorHeight = h;   //UtilGeneralHelper.GetDisplayPixel(this, 100);
    105.  
    106.                 x = (Prefe.DisplayWidth / 2) - (w / 2);
    107.                 y = (Prefe.DisplayHeight / 2) - (h / 2);
    108.  
    109.                 // ver 2.5.9
    110.                 x = (Width / 2) - (w / 2);
    111.                 y = (Height / 2) - (h / 2);
    112.  
    113.             }
    114.  
    115.             //Prefe.DetectionArea = new Rect(x, x, x + Prefe.DetectorWidth, x + Prefe.DetectorHeight);
    116.             Prefe.DetectionArea = new Rect(x, y, x + w, y + h);
    117.  
    118.             Prefe.gDetectionBitmapInt = new int[Prefe.DetectionArea.width() * Prefe.DetectionArea.height()];
    119.             Prefe.gDetectionBitmapIntPrev = new int[Prefe.DetectionArea.width() * Prefe.DetectionArea.height()];
    120.  
    121.         } catch (Exception e) {
    122.             e.printStackTrace();
    123.         }
    124.     }
    125.  
    126.     public static void SetDetectionArea(int x, int y, int w, int h) {
    127.         try {
    128.             Prefe.DetectionArea = new Rect(x, y, w, h);
    129.  
    130.         } catch (Exception e) {
    131.             e.printStackTrace();
    132.         }
    133.     }
    134.  
    135.     private void DrawAreaBox(Canvas canvas) {
    136.         try {
    137.         } catch (Exception e) {
    138.             e.printStackTrace();
    139.         }
    140.     }
    141.  
    142.     @Override
    143.     protected void dispatchDraw(Canvas canvas) {
    144.         try {
    145.             if (this.getRootView().isInEditMode()) {
    146.                 super.dispatchDraw(canvas);
    147.                 return;
    148.             }
    149.  
    150.             //canvas.save(Canvas.MATRIX_SAVE_FLAG);
    151.             //Prefe.DetectionAreaOrient = UtilGeneralHelper.GetDetectRectByOrientation();
    152.  
    153.             canvas.drawColor(0);
    154.             mPath.reset();
    155.  
    156.             canvas.drawRect(Prefe.DetectionArea, BoxPaint);
    157.  
    158.             mPath.moveTo(Prefe.DetectionArea.right - ArrowWidth, Prefe.DetectionArea.bottom);
    159.             mPath.lineTo(Prefe.DetectionArea.right, Prefe.DetectionArea.bottom - ArrowWidth);
    160.             mPath.lineTo(Prefe.DetectionArea.right, Prefe.DetectionArea.bottom);
    161.             mPath.lineTo(Prefe.DetectionArea.right - ArrowWidth, Prefe.DetectionArea.bottom);
    162.             mPath.close();
    163.             canvas.drawPath(mPath, ArrowPaint);
    164.  
    165.             mPath.reset();
    166.             //canvas.drawRect(Prefe.DetectionAreaOrient, BoxPaint2);
    167.             //canvas.drawRect(Prefe.DetectionAreaOrientPort, BoxPaint2);
    168.  
    169.             TextPaint.setTextSize(16);
    170.             //TextPaint.setLetterSpacing(2);
    171.  
    172.             TextPaint.setColor(ContextCompat.getColor(mContext,R.color.bwff));
    173.  
    174.             TextPaint.getTextBounds(getResources().getString(R.string.str_detectarea), 0, 1, mRect);
    175.             canvas.drawText(getResources().getString(R.string.str_detectarea),
    176.                     Prefe.DetectionArea.left + 4,
    177.                     Prefe.DetectionArea.top + 4 + mRect.height(),
    178.                     TextPaint);
    179.             int recH = mRect.height();
    180.  
    181.             TextPaint.setStrokeWidth(1.2f);
    182.             TextPaint.setTextSize(18);
    183.             TextPaint.setColor(ContextCompat.getColor(mContext,R.color.redD_9e));
    184.             TextPaint.getTextBounds(getResources().getString(R.string.str_dragandmove), 0, 1, mRect);
    185.             canvas.drawText(getResources().getString(R.string.str_dragandmove),
    186.                     Prefe.DetectionArea.left + 4,
    187.                     Prefe.DetectionArea.top + 20 + mRect.height()*2,
    188.                     TextPaint);
    189.  
    190.             TextPaint.getTextBounds(getResources().getString(R.string.str_scalearea), 0, 1, mRect);
    191.             canvas.drawText(getResources().getString(R.string.str_scalearea),
    192.                     Prefe.DetectionArea.left + 4,
    193.                     Prefe.DetectionArea.top + 36 + mRect.height()*3,
    194.                     TextPaint);
    195.  
    196.             super.dispatchDraw(canvas);
    197.             //canvas.restore();
    198.         } catch (Exception e) {
    199.             e.printStackTrace();
    200.         }
    201.     }
    202.  
    203.     @Override
    204.     protected void onDraw(Canvas canvas) {
    205.         try {
    206.             super.onDraw(canvas);
    207.             invalidate();
    208.         } catch (Exception e) {
    209.             e.printStackTrace();
    210.         } finally {
    211.  
    212.         }
    213.     }
    214.  
    215.     @Override
    216.     public boolean onTouchEvent(MotionEvent event) {
    217.         boolean retValue = true;
    218.         int X = (int)event.getX();
    219.         int Y = (int)event.getY();
    220.  
    221.  
    222.  
    223.         //AppMain.txtLoc.setText(String.valueOf(X) + ", " + String.valueOf(Y));
    224.  
    225.         switch (event.getAction()) {
    226.             case MotionEvent.ACTION_DOWN:
    227.                 mBoxTouched = TouchedInBoxArea(X, Y);
    228.  
    229.                 //AppMain.txtLoc.setText("BoxTouched: " + String.valueOf(mBoxTouched));
    230.  
    231.                 if (!mBoxTouched) break;
    232.  
    233.                 lastX = X;
    234.                 lastY = Y;
    235.  
    236.                 BoxPaint.setStyle(Style.FILL_AND_STROKE);
    237.                 BoxPaint.setColor(ContextCompat.getColor(mContext,R.color.redD_9e));
    238.  
    239.                 mArrowTouched = TouchedInArrow(X, Y);
    240.                 //AppMain.txtLoc.setText("ArrowTouched: " + String.valueOf(mBoxTouched));
    241.  
    242.                 if (mArrowTouched) {
    243.                     ArrowPaint.setColor(ContextCompat.getColor(mContext,R.color.bwff_9e));
    244.                 }
    245.  
    246.                 break;
    247.  
    248.             case MotionEvent.ACTION_MOVE:
    249.                 if (!mBoxTouched) break;
    250.  
    251.                 int moveX = X - lastX;
    252.                 int moveY = Y - lastY;
    253.  
    254.                 //AppMain.txtLoc.setText("Move X, Y: " + String.valueOf(moveX) + "," + String.valueOf(moveY));
    255.                 if (!mArrowTouched) {
    256.                     if (Prefe.DetectionArea.left + moveX < 0) {
    257.                         break;
    258.                     }
    259.     //                if (Prefe.DetectionArea.right + moveX > Prefe.gDisplay.getWidth()) {
    260.     //                    break;
    261.     //                }
    262.                     // ver 2.5.9
    263.                     if (Prefe.DetectionArea.right + moveX > Width) {
    264.                         break;
    265.                     }
    266.                     if (Prefe.DetectionArea.top + moveY < 0) {
    267.                         break;
    268.                     }
    269.     //                if (Prefe.DetectionArea.bottom + moveY > Prefe.gDisplay.getHeight()) {
    270.     //                    break;
    271.     //                }
    272.                     // ver 2.5.9
    273.                     if (Prefe.DetectionArea.bottom + moveY > Height) {
    274.                         break;
    275.                     }
    276.                 }
    277.  
    278.                 if (mArrowTouched) {
    279.                     if ((Prefe.DetectionArea.width() + moveX) < ArrowWidth * 2){
    280.                         break;
    281.                     }
    282.                     if ((Prefe.DetectionArea.height() + moveY) < ArrowWidth * 2) {
    283.                         break;
    284.                     }
    285.                     Prefe.DetectionArea.right += moveX;
    286.                     Prefe.DetectionArea.bottom += moveY;
    287.                     //Log.i("DBG", "W,H: " + String.valueOf(Prefe.DetectionArea.width()) + "," + String.valueOf(Prefe.DetectionArea.height()));
    288.                 } else {
    289.                     Prefe.DetectionArea.left += moveX;
    290.                     Prefe.DetectionArea.right += moveX;
    291.                     Prefe.DetectionArea.top += moveY;
    292.                     Prefe.DetectionArea.bottom += moveY;
    293.                 }
    294.  
    295.                 lastX = X;
    296.                 lastY = Y;
    297.  
    298.                 //AppMain.txtLoc.setText(String.valueOf(Prefe.DetectionArea.left) + ", " + String.valueOf(Prefe.DetectionArea.top));
    299.                 break;
    300.  
    301.             case MotionEvent.ACTION_UP:
    302.                 mBoxTouched = false;
    303.                 mArrowTouched = false;
    304.                 //BoxPaint.setStyle(Style.STROKE);
    305.                 BoxPaint.setStyle(Style.FILL_AND_STROKE);
    306.                 BoxPaint.setColor(ContextCompat.getColor(mContext,R.color.bwff_60));
    307.                 ArrowPaint.setColor(ContextCompat.getColor(mContext,R.color.redDD));
    308.  
    309.                 //AppMain.txtLoc.setText(String.valueOf(Prefe.DetectionArea.left) + ", " + String.valueOf(Prefe.DetectionArea.top));
    310.  
    311.                 if (Prefe.DetectionArea.left < 0) {
    312.                     Prefe.DetectionArea.left = 0;
    313.                 }
    314.     //            if (Prefe.DetectionArea.right > Prefe.gDisplay.getWidth()) {
    315.     //                Prefe.DetectionArea.right = Prefe.gDisplay.getWidth();
    316.     //            }
    317.                 // ver 2.5.9
    318.                 if (Prefe.DetectionArea.right > Width) {
    319.                     Prefe.DetectionArea.right = Width;
    320.                 }
    321.                 if (Prefe.DetectionArea.top < 0) {
    322.                     Prefe.DetectionArea.top = 0;
    323.                 }
    324.     //            if (Prefe.DetectionArea.bottom > Prefe.gDisplay.getHeight()) {
    325.     //                Prefe.DetectionArea.bottom = Prefe.gDisplay.getHeight();
    326.     //            }
    327.                 if (Prefe.DetectionArea.bottom > Height) {
    328.                     Prefe.DetectionArea.bottom = Height;
    329.                 }
    330.  
    331.                 Prefe.gDetectionBitmapInt = new int[Prefe.DetectionArea.width() * Prefe.DetectionArea.height()];
    332.                 Prefe.gDetectionBitmapIntPrev = new int[Prefe.DetectionArea.width() * Prefe.DetectionArea.height()];
    333.                 //Prefe.gDetectionBitmapInt = null;
    334.                 //Prefe.gDetectionBitmapIntPrev = null;
    335.  
    336.                 String area = String.valueOf(Prefe.DetectionArea.left)
    337.                         + "," + String.valueOf(Prefe.DetectionArea.top)
    338.                         + "," + String.valueOf(Prefe.DetectionArea.right)
    339.                         + "," + String.valueOf(Prefe.DetectionArea.bottom);
    340.  
    341.                // UtilGeneralHelper.SavePreferenceSetting(Prefe.gContext, Prefe.PREF_DETECTION_AREA_KEY, area);
    342.                 //Saving the value
    343.                 SharedPrefsUtils.setStringPreference(mContext.getApplicationContext(), Prefe.PREF_DETECTION_AREA_KEY, area);
    344.                 Log.v("TAG", SharedPrefsUtils.getStringPreference(mContext.getApplicationContext(),Prefe.PREF_DETECTION_AREA_KEY));
    345.  
    346.  
    347.                 break;
    348.         }
    349.  
    350.         invalidate();
    351.         return retValue;
    352.     }
    353.  
    354.     private boolean TouchedInBoxArea(int x, int y) {
    355.         boolean retValue = false;
    356.         try {
    357.  
    358.             if (x > Prefe.DetectionArea.left && x < Prefe.DetectionArea.right) {
    359.                 if (y > Prefe.DetectionArea.top && y < Prefe.DetectionArea.bottom) {
    360.                     retValue = true;
    361.                 }
    362.             }
    363.         } catch (Exception e) {
    364.             e.printStackTrace();
    365.         }
    366.         return retValue;
    367.     }
    368.  
    369.     private boolean TouchedInArrow(int x, int y) {
    370.         boolean retValue = false;
    371.         try {
    372.  
    373.             if (x > Prefe.DetectionArea.right - ArrowWidth && x < Prefe.DetectionArea.right) {
    374.                 if (y > Prefe.DetectionArea.bottom - ArrowWidth && y < Prefe.DetectionArea.bottom) {
    375.                     retValue = true;
    376.                 }
    377.             }
    378.         } catch (Exception e) {
    379.             e.printStackTrace();
    380.         }
    381.         return retValue;
    382.     }
    383.  
    384.     @Override
    385.     protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
    386.         super.onMeasure(widthMeasureSpec, heightMeasureSpec);
    387.         int width = MeasureSpec.getSize(widthMeasureSpec);
    388.         int height = MeasureSpec.getSize(heightMeasureSpec);
    389.         setMeasuredDimension(width, height);
    390.         Width = width;
    391.         Height = height;
    392.         InitDetectionArea();
    393.     }
    394.  
    395.     @Override
    396.     protected void onFinishInflate() {
    397.         super.onFinishInflate();
    398.     }
    399.  
    400.     @Override
    401.     protected void onLayout(boolean changed, int l, int t, int r, int b) {
    402.         // TODO Auto-generated method stub
    403.         for (int i = 0; i < this.getChildCount()-1; i++){
    404.             (this.getChildAt(i)).layout(l, t, r, b);
    405.         }
    406.  
    407.         if (changed) {
    408.             // check width height
    409.             if (r != Width || b != Height) {
    410.                 // size does not match
    411.             }
    412.         }
    413.     }
    414.     }


     

    Advertisement

Share This Page

Loading...