android-developers
[Arriba] [Todas las Listas]

[android-developers] Cómo a cultivo bitmaps según medida de una vista

To: Android Developers <android-developers@xxxxxxxxxxxxxxxx>
Subject: [android-developers] Cómo a cultivo bitmaps según medida de una vista de costumbre para especificar el área de detección de movimiento
From: Dioptre Pic <dp.androtest@xxxxxxxxx>
Date: Tue, 22 Aug 2017 01:11:33 -0700 (PDT)
Delivery-date: Tue, 22 Aug 2017 04:13:00 -0400
Dkim-signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=googlegroups.com; s=20161025; h=sender:date:from:to:message-id:subject:mime-version :x-original-sender:reply-to:precedence:mailing-list:list-id :list-post:list-help:list-archive:list-subscribe:list-unsubscribe; bh=YDORjQfAIeELN4us17j4Oh762GVsAunCj2rl5FkFlbg=; b=HEDO6QsRzq5DbYHPDw1P0G2KHiMzPamQC/tIiAStRp5Fp2x0KF30S3Gm6RDuEPN1VR xNUN8Aakoc9I0XvtujeZjOvPEWwwDKf1628fqly9n78iExTDfaRCJ9uyLkGil+IS21Y6 YB8RvXd9cM7jK0Ahjr194ebUS033nKqUxt0T5utZUT8slrnNciA020Ho2g2AUexVoypT v17+WxoamblPOvIbUX7c6EtET/HPXNJJkaahaHpDZ6WFbv869R48ECxlLXqEN6xFqtvq vEFzXFr9bdGRBv5bacqBt4wMuF7vODmd9/b1F9skuC7PM8qKnvj7MgTkgGmEZh9gh7Yx tb7Q==
Dkim-signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=date:from:to:message-id:subject:mime-version:x-original-sender :reply-to:precedence:mailing-list:list-id:list-post:list-help :list-archive:list-subscribe:list-unsubscribe; bh=YDORjQfAIeELN4us17j4Oh762GVsAunCj2rl5FkFlbg=; b=HtBJVRYJdORSzXLuSKppuOOUHh3NPJqbAuQE8PVIPZtjeU0LWCpfAv+ASVrsqy+v+s foqPPqxkBi1ZYnNvYBwkN3ydFMD84uuTpTUY530XAT1U+IkOiYRcczebN1109V1UuN5W 82Vdra0kAAx3J3bbKrOnErAsdD4ZGkFeUBf+L2lxp4bugOWXqOYz+gGX1Q1oybartzQq od+4Yyo0EgTh4k3ErXTOIbyaZXiNZky0pzge50/+SyW9jfNzXy95E4fi4Nmec+mTb8At yKcZuSgxVeGVMaUMm3qrgcXX6snZ/4yV/K7J9pbFo3ktlJRFwaHQqju0F5kwqubPhnjf SPvQ==
Envelope-to: traductor@xxxxxxxxxxx
List-archive: <https://groups.google.com/group/android-developer>
List-help: <https://groups.google.com/support/>, <mailto:android-developers+help@googlegroups.com>
List-id: <android-developers.googlegroups.com>
List-post: <https://groups.google.com/group/android-developers/post>, <mailto:android-developers@googlegroups.com>
List-subscribe: <https://groups.google.com/group/android-developers/subscribe>, <mailto:android-developers+subscribe@googlegroups.com>
List-unsubscribe: <mailto:googlegroups-manage+364598216046+unsubscribe@googlegroups.com>, <https://groups.google.com/group/android-developers/subscribe>
Mailing-list: list android-developers@xxxxxxxxxxxxxxxx; contact android-developers+owners@xxxxxxxxxxxxxxxx
Reply-to: android-developers@xxxxxxxxxxxxxxxx
Sender: android-developers@xxxxxxxxxxxxxxxx
Probando hacer una detección de movimiento *app basado en este proyecto 
<*https://*github.*com/*jkwiecien/*android-Movimiento-detector>. La intención es para 
hacer el *app tomar cuadros cuándo el movimiento es detectado por comparar dos imágenes. 
Hasta esta parte, el *app está trabajando bien.

*Requisito:*

para especificar área de detección por una vista de costumbre. De modo que, los cuadros serán capturados sólo si un movimiento es detectado dentro del área definida por 
calcular el área de detección. 

*Qué he hecho tan lejos:*

Creado un *movable vista de costumbre, como una vista de cultivo del cual las dimensiones 
(*Rect) es salvado en la preferencia cada tiempo cuándo la vista es movida.

*Qué no está trabajando:*

La detección de movimiento de dentro de la vista de costumbre no está trabajando. Justo 
detecta movimiento para el entero *preview. Creo que el *bitmaps tiene que ser 
*cropped según la medida de la vista de costumbre.
En el hilo de detección probé poner el `ancho` y `la alzada` de la 
preferencia gusta :    
        privado *int ancho = *Prefe.*DetectionArea.Ancho();
        privado *int alzada = *Prefe.*DetectionArea.Alzada();

Pero no trabajó. Complacer ayudarme por explicar cómo esto podría ser conseguido 
de modo que la detección de movimiento pasará según la medida de la 
vista de costumbre y lo que los cambios tendrían que ser hechos en el código. Soy nuevo a *android 
y probando a *self aprende, cualquier ayuda es apreciada.


Código de Fuente del proyecto: 
*https://paseo.*google.*com/Carpetas/de paseo/0*B7-*oKqt7*w49*mbTR6*VWZYVURmVms

**MotionDetectionActivity.*java*

    
Clase pública *MotionDetectionActivity extiende *SensorsActivity


    #adj *static TAG de Cadena final = "*MotionDetectionActivity";
    privado *static largo *mReferenceTime = 0;
    privado *static *IMotionDetection detector = *null;
    público *static *MediaPlayer canción;
    público *static *Vibrator *mVibrator;


    privado *static *SurfaceView *preview = *null;
    privado *static *SurfaceHolder *previewHolder = *null;
    privado *static cámara de Cámara = *null;
    privado *static *boolean *inPreview = falso;
    privado *static *AreaDetectorView *mDetector;
    privado *static *FrameLayout *layoutDetectorArea;
    *static *FrameLayout *layoutMain;
    *static Vista *mView;
    privado *static volátil *AtomicBoolean procesando = nuevo *AtomicBoolean(
falso);@#unknown{^*inheritDoc}
     */
    @*Override
    público *void *onCreate(*Bundle *savedInstanceState)
        #unknown{^*super.*onCreate(*savedInstanceState);
        *getWindow().*addFlags(*WindowManager.*LayoutParams.La BANDERA_MANTIENE_PANTALLA_EN
);
        *setContentView(*R.*layout.Principal);


        *mVibrator = (*Vibrator)esto.*getSystemService(*VIBRATOR_SERVICIO);
        *layoutMain=(*FrameLayout)*findViewById(*R.*id.*layoutMain);
        *preview = (*SurfaceView) *findViewById(*R.*id.*preview);
        *previewHolder = *preview.*getHolder();
        *previewHolder.*addCallback(*surfaceCallback);
        *previewHolder.*setType(*SurfaceHolder.EMPUJÓN_de TIPO_de la SUPERFICIE_*BUFFERS);
        *mView=*layoutMain;
        *mDetector= (*AreaDetectorView) *findViewById(*R.*id.*viewDetector);
        *layoutDetectorArea=(*FrameLayout) *findViewById(*R.*id.*layoutDetectArea
);


        *ToggleButton *toggle = (*ToggleButton) *findViewById(*R.*id.
*simpleToggleButton);
        *toggle.*setOnCheckedChangeListener(Nuevo *CompoundButton.
*OnCheckedChangeListener()
            #Nom *void *onCheckedChanged(*CompoundButton *buttonView, *boolean 
*isChecked)
                #cnj (*isChecked)
                    // #det *toggle es habilitado




                } más
                    // #det *toggle es discapacitado
                }
            }
        });




        si (Preferencias.USO_*RGB)
            #nom = nuevo *RgbMotionDetection();
        } más si (Preferencias.USO_*LUMA)
            #nom = nuevo *LumaMotionDetection();
        } más
            // #ger el Estado basado (*aggregate mapa)
            el detector = nuevo *AggregateLumaMotionDetection();@#unknown{^*inheritDoc}
     */
    @*Override
    público *void *onConfigurationChanged(Configuración *newConfig)
        #unknown{^*super.*onConfigurationChanged(*newConfig);
    }


    /***dd:
     * Juego de canción # 1
     * Cámara *callback@#unknown{^*inheritDoc}
     */
    @*Override
    público *void *onPause()
        #unknown{^*super.*onPause();
        Si(canción!=*null && Canción.*isPlaying())
            #Nom.Parón();}


        cámara.*setPreviewCallback(*null);
        Si (*inPreview) cámara.*stopPreview();
        *inPreview = Falso;
        cámara.Liberación();
        cámara = *null;@#unknown{^*inheritDoc}
     */
    @*Override
    público *void *onResume()
        #unknown{^*super.*onResume();


        Cámara = de cámara.Abierto();
    }


    privado *PreviewCallback *previewCallback = nuevo *PreviewCallback()


        /**
         * {@#unknown{^*inheritDoc}
         */
        @*Override
        público *void *onPreviewFrame(*byte[] dato, Cámara *cam)
            #cnj (dato == *null) regreso;
            Cámara.Medida de medida = *cam.*getParameters().*getPreviewSize();
            Si (medida == *null) regreso;


            si (!*GlobalData.*isPhoneInMotion())
                #unknown{^*DetectionThread El Hilo = nuevo *DetectionThread(dato, medida.
Ancho, medida.Alzada);
                hilo.Inicio();
            }
        }
    };


    privado *SurfaceHolder.*Callback *surfaceCallback = Nuevo *SurfaceHolder.
*Callback()


        /**
         * {@#unknown{^*inheritDoc}
         */
        @*Override
        Público *void *surfaceCreated(*SurfaceHolder titular)
            #verbcj


                #nom.*setPreviewDisplay(*previewHolder);
                Cámara.*setPreviewCallback(*previewCallback);
            } Coge (*Throwable *t)
                #unknown{^*Log.*e("*Prek", "Excepción en *setPreviewDisplay()", *t);@#unknown{^*inheritDoc}
         */
        @*Override
        público *void *surfaceChanged(*SurfaceHolder titular, *int formato, *int 
ancho, *int alzada)
            #cnj(cámara != *null)
                #Nom.Cámara de parámetros = de los parámetros.*getParameters();
                Parámetros.*setFocusMode(Cámara.Parámetros.
MODO_de FOCO_CUADROCONTINUO);
                Cámara.Medida de medida = *getBestPreviewSize(ancho, alzada, 
parámetros);
                si (medida != *null)
                    #Nom.*setPreviewSize(Medida.Ancho, medida.Alzada);
                    *Log.*d(TAG, "Utilizando medida=" + de ancho.Medida + " de alzada=" + 
del ancho.Alzada);
                }
                cámara.*setParameters(Parámetros);
                cámara.*startPreview();
                *inPreview = Cierto;
            }
            //*AreaDetectorView.*InitDetectionArea();@#unknown{^*inheritDoc}
         */
        @*Override
        Público *void *surfaceDestroyed(*SurfaceHolder titular)
            // #verbcj
        }
    };


    privado *static Cámara.Medida *getBestPreviewSize(*int ancho, *int alzada, 
Cámara.Parámetros de parámetros)
        #nom.Resultado de medida = *null;


        puesto que (Cámara.Medida de medida : parámetros.*getSupportedPreviewSizes())
            #Cnj (medida.Medida <= de ancho && del ancho.Alzada <= de alzada)
                #cnj (resultado == *null)
                    #nom_de_nom = de resultado;
                } más
                    #unknown{^*int *resultArea = resultado.Resultado * de ancho.Alzada;
                    *int *newArea = medida.Medida * de ancho.Alzada;


                    si (*newArea > *resultArea) medida = de resultado;
                }
            }
        }


        resultado de regreso;
    }


    //***************Clase de Detección******************//


    clase final privada *DetectionThread extiende Hilo


        #adj *byte[] dato;
        privado *int ancho;
        privado *int alzada;


        público *DetectionThread(*byte[] dato, *int ancho, *int alzada)
            #prn.Dato = de dato;
            esto.Ancho = de ancho;
            esto.Alzada = de alzada;@#unknown{^*inheritDoc}
         */
        @*Override
        público *void carrera()
            #cnj (!Procesando.*compareAndSet(Falso, cierto)) regreso;


            // *Log.*d(TAG, "EMPIEZA PROCESAR...");
            Prueba
                // #adj_nom #Anterior
                *int[] *pre = *null;
                si (Preferencias.SALVA_ANTERIOR) *pre = detector.*getPrevious();


                // Marco actual (con cambios)
                // mucho tiempo *bConversion = Sistema.*currentTimeMillis();
                *int[] *img = *null;
                Si (Preferencias.USO_*RGB)
                    #unknown{^*img = *ImageProcessing.*decodeYUV420*SPtoRGB(dato, ancho, 
alzada);
                } más
                    #unknown{^*img = *ImageProcessing.*decodeYUV420*SPtoLuma(dato, ancho, 
alzada);
                }




                // marco Actual (sin cambios)
                *int[] *org = *null;
                si (Preferencias.SALVA_ORIGINAL && *img != *null) *org = *img.
Clon();


                si (*img != *null && Detector.Detecta(*img, ancho, alzada))




                    // #det_nom #retraso es necesario de evitar tomando un cuadro 
mientras en
                    // el
                    // *middle de tomar otro. Este problema puede causa 
algunos
                    // telefonea
                    // a *reboot.
                    Mucho tiempo ahora = Sistema.*currentTimeMillis();
                    Si (ahora > (*mReferenceTime + Preferencias.RETRASO_de CUADRO))
                        #unknown{^*mReferenceTime = ahora;


                        //*mVibrator.*vibrate(10);


                        *Bitmap anterior = *null;
                        si (Preferencias.SALVA_ANTERIOR && *pre != *null)
                            #Cnj (Preferencias.USO_*RGB) anterior = 
*ImageProcessing.*rgbToBitmap(*pre, ancho, alzada);
                            más anterior = *ImageProcessing.*lumaToGreyscale(
*pre, ancho, alzada);
                        }


                        *Bitmap original = *null;
                        si (Preferencias.SALVA_ORIGINAL && *org != *null)
                            #Cnj (Preferencias.USO_*RGB) original = 
*ImageProcessing.*rgbToBitmap(*org, ancho, alzada);
                            más original = *ImageProcessing.*lumaToGreyscale(
*org, ancho, alzada);
                        }


                        *Bitmap *bitmap = *null;
                        si (Preferencias.SALVAR_CAMBIOS)
                            #cnj (Preferencias.USO_*RGB) *bitmap = 
*ImageProcessing.*rgbToBitmap(*img, ancho, alzada);
                            más *bitmap = *ImageProcessing.*lumaToGreyscale(
*img, ancho, alzada);
                        }
                        *Log.*i(TAG, "Ahorro.. original original " 
anterior=" + Anterior + " *bitmap=" + *bitmap);
                        *Looper.Prepara();
                        nuevo *SavePhotoTask().Ejecuta(anterior, original, 
*bitmap);
                    } más
                        #unknown{^*Log.*i(TAG, "No tomando cuadro porque no bastante 
tiempo ha pasado desde la creación de la Superficie");
                    }
                }
            } coge (Excepción *e)
                #unknown{^*e.*printStackTrace();
            } Finalmente
                #ger.Conjunto(falso);
            }
            // *Log.*d(TAG, "el FIN que PROCESA...");
            Procesando.Conjunto(falso);
        }
    };


    privado *static clase final *SavePhotoTask extiende *AsyncTask<*Bitmap, 
*Integer, *Integer


        /**
         * {@#unknown{^*inheritDoc}
         */
        @*Override
        protegió *Integer *doInBackground(*Bitmap... Dato)
            #cnj (*int *i = 0; *i < dato.Longitud; *i++)
                #unknown{^*Bitmap *bitmap = dato[*i];
                Cadena de nombre = de la Cadena.*valueOf(Sistema.*currentTimeMillis());
                Si (*bitmap != *null) Salva(nombre, *bitmap);
            }
            regreso 1;
        }


        privado *void salvar(nombre de Cadena, *Bitmap *bitmap)
            #nom_de_nom de Archivo = Archivo nuevo(Entorno.*getExternalStorageDirectory(), 
nombre + ".*jpg");
            Si (foto.Existe()) foto.Elimina();


            prueba
                #unknown{^*FileOutputStream *fos = nuevo *FileOutputStream(foto.*getPath
());
                *bitmap.*compress(*Bitmap.*CompressFormat.JPEG, 100, *fos);
                *fos.Cercano();
            } coge (*java.*io.*IOException *e)
                #unknown{^*Log.*e("*PictureDemo", "Excepción en *photoCallback", *e);
            }
        }
    }
    }


**AreaDetectorView.*java*

    
Clase pública  *AreaDetectorView extiende *LinearLayout


    #nom *static *int Ancho;
    público *static *int Alzada;


    privado *static Pintura *BoxPaint = *null;
    privado *static Pintura *TextPaint = *null;
    privado *static Pintura *ArrowPaint = *null;
    privado *static Camino *mPath = *null;
    privado *static *Rect *mRect = *null;
    privado *static *int *lastX, *lastY = 0;
    privado *static *boolean *mBoxTouched = falso;
    privado *static *boolean *mArrowTouched = falso;
    privado *static Contexto *mContext;
    privado *static *int *ArrowWidth = 0;
    privado *static Pintura *BoxPaint2 = *null;


    público *AreaDetectorView(contexto de Contexto)
        #unknown{^*super(contexto);
        *mContext = contexto;
    }
    //*attrs no fue allí
    público *AreaDetectorView(contexto de Contexto, *AttributeSet *attrs)
        #unknown{^*super(contexto,*attrs);
        *mContext = contexto;
        // *TODO Coche-colilla de constructor generado
        si (!Esto.*getRootView().*isInEditMode())
            #unknown{^*ArrowWidth =*GetDisplayPixel(Contexto, 30);
        }


        //*InitDetectionArea();


        *InitMemberVariables();
        *setWillNotDraw(falso);
    }
    público *static *int *GetDisplayPixel(Contexto *paramContext, *int *paramInt)
        #nom (*int)(*paramInt * *paramContext.*getResources().
*getDisplayMetrics().Densidad + 0.5F);
    }


    público *static *void *InitMemberVariables()
        #cnj (*BoxPaint == *null)
            #unknown{^*BoxPaint = Pintura nueva();
            *BoxPaint.*setAntiAlias(Cierto);
            *BoxPaint.*setStrokeWidth(2.0*f);
            //*BoxPaint.*setStyle(Estilo.GOLPE);
            *BoxPaint.*setStyle(Estilo.LLENAR_Y_GOLPE);
            *BoxPaint.*setColor(*ContextCompat.*getColor(*mContext, *R.*color.
*bwff_60));
        }
        si (*ArrowPaint == *null)
            #unknown{^*ArrowPaint = Pintura nueva();
            *ArrowPaint.*setAntiAlias(Cierto);
            *ArrowPaint.*setColor(*ContextCompat.*getColor(*mContext,*R.*color.
*redDD));
            *ArrowPaint.*setStyle(Estilo.LLENAR_Y_GOLPE);
        }
        si (*TextPaint == *null)
            #unknown{^*TextPaint = Pintura nueva();
            *TextPaint.*setColor(*ContextCompat.*getColor(*mContext,*R.*color.
*yellowL));
            *TextPaint.*setTextSize(16);
            //*txtPaint.*setTypeface(*lcd);
            *TextPaint.*setStyle(Estilo.LLENAR_Y_GOLPE);
        }
        si (*mPath == *null)
            #unknown{^*mPath = Camino nuevo();
        } más
            #unknown{^*mPath.*reset();
        }
        Si (*mRect == *null)
            #unknown{^*mRect = nuevo *Rect();
        }


        si (*BoxPaint2 == *null)
            #unknown{^*BoxPaint2 = Pintura nueva();
            *BoxPaint2.*setAntiAlias(Cierto);
            *BoxPaint2.*setStrokeWidth(2.0*f);
            //*BoxPaint.*setStyle(Estilo.GOLPE);
            *BoxPaint2.*setStyle(Estilo.GOLPE);
            *BoxPaint2.*setColor(*ContextCompat.*getColor(*mContext,*R.*color.
*bwff_9*e));
        }


    }


    público *static *void *InitDetectionArea()
        #verbcj
            #unknown{^*int *w = *Prefe.*DetectionArea.Ancho();
            *int *h = *Prefe.*DetectionArea.Alzada();
            *int *x = *Prefe.*DetectionArea.A la izquierda;
            *int *y = *Prefe.*DetectionArea.Superior;


            // *ver 2.6.0
            si (*Prefe.*DetectionArea.Izquierdo == 1
                    && *Prefe.*DetectionArea.Superior == 1
                    && *Prefe.*DetectionArea.Correcto == 1
                    && *Prefe.*DetectionArea.Inferior == 1)


                #unknown{^*w = *Prefe.*DisplayWidth / 4;
                *h = *Prefe.*DisplayHeight / 3;


                // *ver 2.5.9
                *w = Ancho / 4;
                *h = Alzada / 3;


                *Prefe.*DetectorWidth = *w;    //*UtilGeneralHelper.*GetDisplayPixel(Esto, 
100);
                *Prefe.*DetectorHeight = *h;   //*UtilGeneralHelper.*GetDisplayPixel(Esto, 
100);


                *x = (*Prefe.*DisplayWidth / 2) - (*w / 2);
                *y = (*Prefe.*DisplayHeight / 2) - (*h / 2);


                // *ver 2.5.9
                *x = (Ancho / 2) - (*w / 2);
                *y = (Alzada / 2) - (*h / 2);


            }


            //*Prefe.*DetectionArea = Nuevo *Rect(*x, *x, *x + *Prefe.*DetectorWidth, 
*x + *Prefe.*DetectorHeight);
            *Prefe.*DetectionArea = Nuevo *Rect(*x, *y, *x + *w, *y + *h);


            *Prefe.*gDetectionBitmapInt = Nuevo *int[*Prefe.*DetectionArea.Ancho() 
* *Prefe.*DetectionArea.Alzada()];
            *Prefe.*gDetectionBitmapIntPrev = Nuevo *int[*Prefe.*DetectionArea.
Ancho() * *Prefe.*DetectionArea.Alzada()];


        } coge (Excepción *e)
            #unknown{^*e.*printStackTrace();
        }
    }


    Público *static *void *SetDetectionArea(*int *x, *int *y, *int *w, *int *h)
        #verbcj
            #unknown{^*Prefe.*DetectionArea = Nuevo *Rect(*x, *y, *w, *h);


        } coge (Excepción *e)
            #unknown{^*e.*printStackTrace();
        }
    }


    Privado *void *DrawAreaBox(tela de Tela)
        #verbcj {
        } coge (Excepción *e)
            #unknown{^*e.*printStackTrace();
        }
    }


    @*Override
    Protegió *void *dispatchDraw(tela de Tela)
        #verbcj
            #cnj (esto.*getRootView().*isInEditMode())
                #unknown{^*super.*dispatchDraw(Tela);
                regreso;
            }


            //tela.Salva(Tela.La MATRIZ_SALVA_BANDERA);
            //*Prefe.*DetectionAreaOrient = 
*UtilGeneralHelper.*GetDetectRectByOrientation();


            Tela.*drawColor(0);
            *mPath.*reset();


            Tela.*drawRect(*Prefe.*DetectionArea, *BoxPaint);


            *mPath.*moveTo(*Prefe.*DetectionArea.Correcto - *ArrowWidth, *Prefe.
*DetectionArea.Fondo);
            *mPath.*lineTo(*Prefe.*DetectionArea.Bien, *Prefe.*DetectionArea.Inferior 
- *ArrowWidth);
            *mPath.*lineTo(*Prefe.*DetectionArea.Bien, *Prefe.*DetectionArea.
Fondo);
            *mPath.*lineTo(*Prefe.*DetectionArea.Correcto - *ArrowWidth, *Prefe.
*DetectionArea.Fondo);
            *mPath.Cercano();
            tela.*drawPath(*mPath, *ArrowPaint);


            *mPath.*reset();
            //Tela.*drawRect(*Prefe.*DetectionAreaOrient, *BoxPaint2);
            //tela.*drawRect(*Prefe.*DetectionAreaOrientPort, *BoxPaint2);


            *TextPaint.*setTextSize(16);
            //*TextPaint.*setLetterSpacing(2);


            *TextPaint.*setColor(*ContextCompat.*getColor(*mContext,*R.*color.*bwff
));


            *TextPaint.*getTextBounds(*getResources().*getString(*R.Cadena.
*str_*detectarea), 0, 1, *mRect);
            tela.*drawText(*getResources().*getString(*R.Cadena.*str_*detectarea
),
                    *Prefe.*DetectionArea.Izquierdo + 4,
                    *Prefe.*DetectionArea.Superior + 4 + *mRect.Alzada(),
                    *TextPaint);
            *int *recH = *mRect.Alzada();


            *TextPaint.*setStrokeWidth(1.2*f);
            *TextPaint.*setTextSize(18);
            *TextPaint.*setColor(*ContextCompat.*getColor(*mContext,*R.*color.
*redD_9*e));
            *TextPaint.*getTextBounds(*getResources().*getString(*R.Cadena.
*str_*dragandmove), 0, 1, *mRect);
            tela.*drawText(*getResources().*getString(*R.Cadena.
*str_*dragandmove),
                    *Prefe.*DetectionArea.Izquierdo + 4,
                    *Prefe.*DetectionArea.Superior + 20 + *mRect.Alzada()*2,
                    *TextPaint);


            *TextPaint.*getTextBounds(*getResources().*getString(*R.Cadena.
*str_*scalearea), 0, 1, *mRect);
            tela.*drawText(*getResources().*getString(*R.Cadena.*str_*scalearea
),
                    *Prefe.*DetectionArea.Izquierdo + 4,
                    *Prefe.*DetectionArea.Superior + 36 + *mRect.Alzada()*3,
                    *TextPaint);


            *super.*dispatchDraw(Tela);
            //tela.Restaura();
        } coge (Excepción *e)
            #unknown{^*e.*printStackTrace();
        }
    }


    @*Override
    Protegió *void *onDraw(tela de Tela)
        #verbcj
            #unknown{^*super.*onDraw(Tela);
            invalida();
        } coge (Excepción *e)
            #unknown{^*e.*printStackTrace();
        } Finalmente {


        }
    }


    @*Override
    público *boolean *onTouchEvent(*MotionEvent acontecimiento)
        #unknown{^*boolean *retValue = cierto;
        *int *X = (*int)acontecimiento.*getX();
        *int *Y = (*int)Acontecimiento.*getY();






        //*AppMain.*txtLoc.*setText(Cadena.*valueOf(*X) + ", " + 
Cadena.*valueOf(*Y));


        Cambio (acontecimiento.*getAction())
            #Nom *MotionEvent.ACCIÓN_ABAJO:
                *mBoxTouched = *TouchedInBoxArea(*X, *Y);


                //*AppMain.*txtLoc.*setText("*BoxTouched: " + 
Cadena.*valueOf(*mBoxTouched));


                Si (!*mBoxTouched) Rotura;


                *lastX = *X;
                *lastY = *Y;


                *BoxPaint.*setStyle(Estilo.LLENAR_Y_GOLPE);
                *BoxPaint.*setColor(*ContextCompat.*getColor(*mContext,*R.*color.
*redD_9*e));


                *mArrowTouched = *TouchedInArrow(*X, *Y);
                //*AppMain.*txtLoc.*setText("*ArrowTouched: " + 
Cadena.*valueOf(*mBoxTouched));


                Si (*mArrowTouched)
                    #unknown{^*ArrowPaint.*setColor(*ContextCompat.*getColor(*mContext,*R.
*color.*bwff_9*e));
                }


                rotura;


            caso *MotionEvent.MOVIMIENTO_de ACCIÓN:
                si (!*mBoxTouched) Rotura;


                *int *moveX = *X - *lastX;
                *int *moveY = *Y - *lastY;


                //*AppMain.*txtLoc.*setText("Movimiento *X, *Y: " + 
Cadena.*valueOf(*moveX) + "," + Cadena.*valueOf(*moveY));
                Si (!*mArrowTouched)
                    #Cnj (*Prefe.*DetectionArea.Izquierdo + *moveX < 0)
                        #nom;
                    }
    //     si (*Prefe.*DetectionArea.Correcto + *moveX > 
*Prefe.*gDisplay.*getWidth())
    //     #Nom;
    //     }
                    // *ver 2.5.9
                    si (*Prefe.*DetectionArea.Correcto + *moveX > Ancho)
                        #nom;
                    }
                    si (*Prefe.*DetectionArea.Superior + *moveY < 0)
                        #nom;
                    }
    //     si (*Prefe.*DetectionArea.Fondo + *moveY > 
*Prefe.*gDisplay.*getHeight())
    //     #Nom;
    //     }
                    // *ver 2.5.9
                    si (*Prefe.*DetectionArea.Inferior + *moveY > Alzada)
                        #nom;
                    }
                }


                si (*mArrowTouched)
                    #cnj ((*Prefe.*DetectionArea.Ancho() + *moveX) < *ArrowWidth * 
2)
                        #nom;
                    }
                    si ((*Prefe.*DetectionArea.Alzada() + *moveY) < *ArrowWidth 
* 2)
                        #nom;
                    }
                    *Prefe.*DetectionArea.Correcto += *moveX;
                    *Prefe.*DetectionArea.Inferior += *moveY;
                    //*Log.*i("*DBG", "*W,*H: " + 
Cadena.*valueOf(*Prefe.*DetectionArea.Ancho()) + "," + 
Cadena.*valueOf(*Prefe.*DetectionArea.Alzada()));
                } más
                    #unknown{^*Prefe.*DetectionArea.Izquierdo += *moveX;
                    *Prefe.*DetectionArea.Correcto += *moveX;
                    *Prefe.*DetectionArea.Superior += *moveY;
                    *Prefe.*DetectionArea.Inferior += *moveY;
                }


                *lastX = *X;
                *lastY = *Y;


                //*AppMain.*txtLoc.*setText(Cadena.*valueOf(*Prefe.*DetectionArea.Izquierdo) 
+ ", " + Cadena.*valueOf(*Prefe.*DetectionArea.Parte superior));
                rotura;


            caso *MotionEvent.UP_de ACCIÓN:
                *mBoxTouched = falso;
                *mArrowTouched = falso;
                //*BoxPaint.*setStyle(Estilo.GOLPE);
                *BoxPaint.*setStyle(Estilo.LLENAR_Y_GOLPE);
                *BoxPaint.*setColor(*ContextCompat.*getColor(*mContext,*R.*color.
*bwff_60));
                *ArrowPaint.*setColor(*ContextCompat.*getColor(*mContext,*R.*color.
*redDD));


                //*AppMain.*txtLoc.*setText(Cadena.*valueOf(*Prefe.*DetectionArea.Izquierdo) 
+ ", " + Cadena.*valueOf(*Prefe.*DetectionArea.Parte superior));


                si (*Prefe.*DetectionArea.Izquierdo < 0)
                    #unknown{^*Prefe.*DetectionArea.Izquierdo = 0;
                }
    //     si (*Prefe.*DetectionArea.Correcto > *Prefe.*gDisplay.*getWidth())
    //     #unknown{^*Prefe.*DetectionArea.Correcto = *Prefe.*gDisplay.*getWidth();
    //     }
                // *ver 2.5.9
                si (*Prefe.*DetectionArea.Ancho > correcto)
                    #unknown{^*Prefe.*DetectionArea.Ancho correcto;
                }
                si (*Prefe.*DetectionArea.Superior < 0)
                    #unknown{^*Prefe.*DetectionArea.Superior = 0;
                }
    //     si (*Prefe.*DetectionArea.Inferior > *Prefe.*gDisplay.*getHeight())
    //     #unknown{^*Prefe.*DetectionArea.Inferior = *Prefe.*gDisplay.*getHeight();
    //     }
                Si (*Prefe.*DetectionArea.Alzada > inferior)
                    #unknown{^*Prefe.*DetectionArea.Alzada inferior;
                }


                *Prefe.*gDetectionBitmapInt = Nuevo *int[*Prefe.*DetectionArea.
Ancho() * *Prefe.*DetectionArea.Alzada()];
                *Prefe.*gDetectionBitmapIntPrev = Nuevo *int[*Prefe.*DetectionArea.
Ancho() * *Prefe.*DetectionArea.Alzada()];
                //*Prefe.*gDetectionBitmapInt = *null;
                //*Prefe.*gDetectionBitmapIntPrev = *null;


                Cadena de área = de la cadena.*valueOf(*Prefe.*DetectionArea.Izquierdo)
                        + "," + Cadena.*valueOf(*Prefe.*DetectionArea.Parte superior)
                        + "," + Cadena.*valueOf(*Prefe.*DetectionArea.Correcto)
                        + "," + Cadena.*valueOf(*Prefe.*DetectionArea.Fondo);


               // *UtilGeneralHelper.*SavePreferenceSetting(*Prefe.*gContext, 
*Prefe.*PREF_LLAVE_de ÁREA_de la DETECCIÓN, área);
                //Salvando el valor
                *SharedPrefsUtils.*setStringPreference(*mContext.
*getApplicationContext(), *Prefe.*PREF_LLAVE_de ÁREA_de la DETECCIÓN, área);
                *Log.*v("TAG", *SharedPrefsUtils.*getStringPreference(*mContext.
*getApplicationContext(),*Prefe.*PREF_LLAVE_de ÁREA_de la DETECCIÓN));




                rotura;
        }


        invalida();
        regreso *retValue;
    }


    privado *boolean *TouchedInBoxArea(*int *x, *int *y)
        #unknown{^*boolean *retValue = falso;
        probar


            #cnj (*x > *Prefe.*DetectionArea.Izquierdo && *x < *Prefe.*DetectionArea.
Correcto)
                #cnj (*y > *Prefe.*DetectionArea.Superior && *y < *Prefe.*DetectionArea.
Fondo)
                    #unknown{^*retValue = cierto;
                }
            }
        } coge (Excepción *e)
            #unknown{^*e.*printStackTrace();
        }
        Regreso *retValue;
    }


    privado *boolean *TouchedInArrow(*int *x, *int *y)
        #unknown{^*boolean *retValue = falso;
        probar


            #cnj (*x > *Prefe.*DetectionArea.Correcto - *ArrowWidth && *x < *Prefe.
*DetectionArea.Correcto)
                #cnj (*y > *Prefe.*DetectionArea.Inferior - *ArrowWidth && *y < *Prefe
.*DetectionArea.Fondo)
                    #unknown{^*retValue = cierto;
                }
            }
        } coge (Excepción *e)
            #unknown{^*e.*printStackTrace();
        }
        Regreso *retValue;
    }


    @*Override
    protegió *void *onMeasure(*int *widthMeasureSpec, *int *heightMeasureSpec)
        #unknown{^*super.*onMeasure(*widthMeasureSpec, *heightMeasureSpec);
        *int ancho = *MeasureSpec.*getSize(*widthMeasureSpec);
        *int Alzada = *MeasureSpec.*getSize(*heightMeasureSpec);
        *setMeasuredDimension(Ancho, alzada);
        ancho = de Ancho;
        alzada = de Alzada;
        *InitDetectionArea();
    }


    @*Override
    protegió *void *onFinishInflate()
        #unknown{^*super.*onFinishInflate();
    }


    @*Override
    Protegió *void *onLayout(*boolean cambiado, *int *l, *int *t, *int *r, *int *b)
        // #unknown{^*TODO Coche-colilla de método generado
        puesto que (*int *i = 0; *i < esto.*getChildCount()-1; *i++)
            #default{^(esto.*getChildAt(*i)).*layout(*l, *t, *r, *b);
        }


        si (cambiado)
            // #nom_nom_nom de ancho del control
            si (*r != Ancho || *b != Alzada)
                // #nom no empareja
            }
        }
    }
    }

**Prefe.*java*

    
Clase pública *Prefe extiende Aplicación
    #punt..
    Público *static Cadena final *PREF_ÁREA_de DETECCIÓN_CLAVE = 
"*pref_llave_de área_de la detección";
    }
    *static
    #punt..
    *DetectionArea = Nuevo *Rect(1, 1, 1, 1);
    }
    }



-- 
recibiste este mensaje porque eres *subscribed al *Google Grupos "*Android *Developers" grupo.
A *unsubscribe de este grupo y la parón que recibe *emails de él, enviar un *email a *android-*developers+unsubscribe@xxxxxxxxxxxxxxxx.
A correo a este grupo, envía *email a *android-developers@xxxxxxxxxxxxxxxx.
Visita este grupo en *https://grupos.*google.*com/Grupo/*android-*developers.
Para ver esta discusión en la visita de web *https://grupos.*google.*com/*d/*msgid/*android-*developers/75*ec72*f3-7*d44-4231-89*f4-41*e1*ae4*f7*dec%40*googlegroups.*com.
Para más opciones, visita *https://grupos.*google.*com/*d/*optout.
Trying to make a motion detection app based on this project 
<https://github.com/jkwiecien/android-motion-detector>. 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. It just 
detects motion for the entire preview. I believe that the bitmaps must be 
cropped according to the size of the custom view.
In the detection thread I tried setting the `width` and `height` from the 
preference like :    
        private int width = Prefe.DetectionArea.width();
        private int height = Prefe.DetectionArea.height();

But it didn't work. Please help me by explaining how this could be achieved 
so that the motion detection will happen according to the size of the 
custom view and what changes should be made in the code. I'm new to android 
and trying to self learn, any help is appreciated.


Project Source Code: 
https://drive.google.com/drive/folders/0B7-oKqt7w49mbTR6VWZYVURmVms

*MotionDetectionActivity.java*

    
public class MotionDetectionActivity extends SensorsActivity {


    private static final String TAG = "MotionDetectionActivity";
    private static long mReferenceTime = 0;
    private static IMotionDetection detector = null;
    public static MediaPlayer song;
    public static Vibrator mVibrator;


    private static SurfaceView preview = null;
    private static SurfaceHolder previewHolder = null;
    private static Camera camera = null;
    private static boolean inPreview = false;
    private static AreaDetectorView mDetector;
    private static FrameLayout layoutDetectorArea;
    static FrameLayout layoutMain;
    static View mView;
    private static volatile AtomicBoolean processing = new AtomicBoolean(
false);


    /**
     * {@inheritDoc}
     */
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        getWindow().addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON
);
        setContentView(R.layout.main);


        mVibrator = (Vibrator)this.getSystemService(VIBRATOR_SERVICE);
        layoutMain=(FrameLayout)findViewById(R.id.layoutMain);
        preview = (SurfaceView) findViewById(R.id.preview);
        previewHolder = preview.getHolder();
        previewHolder.addCallback(surfaceCallback);
        previewHolder.setType(SurfaceHolder.SURFACE_TYPE_PUSH_BUFFERS);
        mView=layoutMain;
        mDetector= (AreaDetectorView) findViewById(R.id.viewDetector);
        layoutDetectorArea=(FrameLayout) findViewById(R.id.layoutDetectArea
);


        ToggleButton toggle = (ToggleButton) findViewById(R.id.
simpleToggleButton);
        toggle.setOnCheckedChangeListener(new CompoundButton.
OnCheckedChangeListener() {
            public void onCheckedChanged(CompoundButton buttonView, boolean 
isChecked) {
                if (isChecked) {
                    // The toggle is enabled




                } else {
                    // The toggle is disabled
                }
            }
        });




        if (Preferences.USE_RGB) {
            detector = new RgbMotionDetection();
        } else if (Preferences.USE_LUMA) {
            detector = new LumaMotionDetection();
        } else {
            // Using State based (aggregate map)
            detector = new AggregateLumaMotionDetection();
        }
    }


    /**
     * {@inheritDoc}
     */
    @Override
    public void onConfigurationChanged(Configuration newConfig) {
        super.onConfigurationChanged(newConfig);
    }


    /**dd:
     * Song play # 1
     * Camera callback
     *
     * {@inheritDoc}
     */
    @Override
    public void onPause() {
        super.onPause();
        if(song!=null && song.isPlaying())
        {
            song.stop();}


        camera.setPreviewCallback(null);
        if (inPreview) camera.stopPreview();
        inPreview = false;
        camera.release();
        camera = null;
    }


    /**
     * {@inheritDoc}
     */
    @Override
    public void onResume() {
        super.onResume();


        camera = Camera.open();
    }


    private PreviewCallback previewCallback = new PreviewCallback() {


        /**
         * {@inheritDoc}
         */
        @Override
        public void onPreviewFrame(byte[] data, Camera cam) {
            if (data == null) return;
            Camera.Size size = cam.getParameters().getPreviewSize();
            if (size == null) return;


            if (!GlobalData.isPhoneInMotion()) {
                DetectionThread thread = new DetectionThread(data, size.
width, size.height);
                thread.start();
            }
        }
    };


    private SurfaceHolder.Callback surfaceCallback = new SurfaceHolder.
Callback() {


        /**
         * {@inheritDoc}
         */
        @Override
        public void surfaceCreated(SurfaceHolder holder) {
            try {


                camera.setPreviewDisplay(previewHolder);
                camera.setPreviewCallback(previewCallback);
            } catch (Throwable t) {
                Log.e("Prek", "Exception in setPreviewDisplay()", t);
            }
        }


        /**
         * {@inheritDoc}
         */
        @Override
        public void surfaceChanged(SurfaceHolder holder, int format, int 
width, int height) {
            if(camera != null) {
                Camera.Parameters parameters = camera.getParameters();
                parameters.setFocusMode(Camera.Parameters.
FOCUS_MODE_CONTINUOUS_PICTURE);
                Camera.Size size = getBestPreviewSize(width, height, 
parameters);
                if (size != null) {
                    parameters.setPreviewSize(size.width, size.height);
                    Log.d(TAG, "Using width=" + size.width + " height=" + 
size.height);
                }
                camera.setParameters(parameters);
                camera.startPreview();
                inPreview = true;
            }
            //AreaDetectorView.InitDetectionArea();
        }


        /**
         * {@inheritDoc}
         */
        @Override
        public void surfaceDestroyed(SurfaceHolder holder) {
            // Ignore
        }
    };


    private static Camera.Size getBestPreviewSize(int width, int height, 
Camera.Parameters parameters) {
        Camera.Size result = null;


        for (Camera.Size size : parameters.getSupportedPreviewSizes()) {
            if (size.width <= width && size.height <= height) {
                if (result == null) {
                    result = size;
                } else {
                    int resultArea = result.width * result.height;
                    int newArea = size.width * size.height;


                    if (newArea > resultArea) result = size;
                }
            }
        }


        return result;
    }


    //***************Detection Class******************//


    private final class DetectionThread extends Thread {


        private byte[] data;
        private int width;
        private int height;


        public DetectionThread(byte[] data, int width, int height) {
            this.data = data;
            this.width = width;
            this.height = height;
        }


        /**
         * {@inheritDoc}
         */
        @Override
        public void run() {
            if (!processing.compareAndSet(false, true)) return;


            // Log.d(TAG, "BEGIN PROCESSING...");
            try {
                // Previous frame
                int[] pre = null;
                if (Preferences.SAVE_PREVIOUS) pre = detector.getPrevious();


                // Current frame (with changes)
                // long bConversion = System.currentTimeMillis();
                int[] img = null;
                if (Preferences.USE_RGB) {
                    img = ImageProcessing.decodeYUV420SPtoRGB(data, width, 
height);
                } else {
                    img = ImageProcessing.decodeYUV420SPtoLuma(data, width, 
height);
                }




                // Current frame (without changes)
                int[] org = null;
                if (Preferences.SAVE_ORIGINAL && img != null) org = img.
clone();


                if (img != null && detector.detect(img, width, height)) {




                    // The delay is necessary to avoid taking a picture 
while in
                    // the
                    // middle of taking another. This problem can causes 
some
                    // phones
                    // to reboot.
                    long now = System.currentTimeMillis();
                    if (now > (mReferenceTime + Preferences.PICTURE_DELAY)) 
{
                        mReferenceTime = now;


                        //mVibrator.vibrate(10);


                        Bitmap previous = null;
                        if (Preferences.SAVE_PREVIOUS && pre != null) {
                            if (Preferences.USE_RGB) previous = 
ImageProcessing.rgbToBitmap(pre, width, height);
                            else previous = ImageProcessing.lumaToGreyscale(
pre, width, height);
                        }


                        Bitmap original = null;
                        if (Preferences.SAVE_ORIGINAL && org != null) {
                            if (Preferences.USE_RGB) original = 
ImageProcessing.rgbToBitmap(org, width, height);
                            else original = ImageProcessing.lumaToGreyscale(
org, width, height);
                        }


                        Bitmap bitmap = null;
                        if (Preferences.SAVE_CHANGES) {
                            if (Preferences.USE_RGB) bitmap = 
ImageProcessing.rgbToBitmap(img, width, height);
                            else bitmap = ImageProcessing.lumaToGreyscale(
img, width, height);
                        }
                        Log.i(TAG, "Saving.. previous=" + previous + " 
original=" + original + " bitmap=" + bitmap);
                        Looper.prepare();
                        new SavePhotoTask().execute(previous, original, 
bitmap);
                    } else {
                        Log.i(TAG, "Not taking picture because not enough 
time has passed since the creation of the Surface");
                    }
                }
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                processing.set(false);
            }
            // Log.d(TAG, "END PROCESSING...");
            processing.set(false);
        }
    };


    private static final class SavePhotoTask extends AsyncTask<Bitmap, 
Integer, Integer> {


        /**
         * {@inheritDoc}
         */
        @Override
        protected Integer doInBackground(Bitmap... data) {
            for (int i = 0; i < data.length; i++) {
                Bitmap bitmap = data[i];
                String name = String.valueOf(System.currentTimeMillis());
                if (bitmap != null) save(name, bitmap);
            }
            return 1;
        }


        private void save(String name, Bitmap bitmap) {
            File photo = new File(Environment.getExternalStorageDirectory(), 
name + ".jpg");
            if (photo.exists()) photo.delete();


            try {
                FileOutputStream fos = new FileOutputStream(photo.getPath
());
                bitmap.compress(Bitmap.CompressFormat.JPEG, 100, fos);
                fos.close();
            } catch (java.io.IOException e) {
                Log.e("PictureDemo", "Exception in photoCallback", e);
            }
        }
    }
    }


*AreaDetectorView.java*

    
public class  AreaDetectorView extends LinearLayout {


    public static int Width;
    public static int Height;


    private static Paint BoxPaint = null;
    private static Paint TextPaint = null;
    private static Paint ArrowPaint = null;
    private static Path mPath = null;
    private static Rect mRect = null;
    private static int lastX, lastY = 0;
    private static boolean mBoxTouched = false;
    private static boolean mArrowTouched = false;
    private static Context mContext;
    private static int ArrowWidth = 0;
    private static Paint BoxPaint2 = null;


    public AreaDetectorView(Context context) {
        super(context);
        mContext = context;
    }
    //attrs was not there
    public AreaDetectorView(Context context, AttributeSet attrs) {
        super(context,attrs);
        mContext = context;
        // TODO Auto-generated constructor stub
        if (!this.getRootView().isInEditMode()) {
            ArrowWidth =GetDisplayPixel(context, 30);
        }


        //InitDetectionArea();


        InitMemberVariables();
        setWillNotDraw(false);
    }
    public static int GetDisplayPixel(Context paramContext, int paramInt)
    {
        return (int)(paramInt * paramContext.getResources().
getDisplayMetrics().density + 0.5F);
    }


    public static void InitMemberVariables() {
        if (BoxPaint == null) {
            BoxPaint = new Paint();
            BoxPaint.setAntiAlias(true);
            BoxPaint.setStrokeWidth(2.0f);
            //BoxPaint.setStyle(Style.STROKE);
            BoxPaint.setStyle(Style.FILL_AND_STROKE);
            BoxPaint.setColor(ContextCompat.getColor(mContext, R.color.
bwff_60));
        }
        if (ArrowPaint == null) {
            ArrowPaint = new Paint();
            ArrowPaint.setAntiAlias(true);
            ArrowPaint.setColor(ContextCompat.getColor(mContext,R.color.
redDD));
            ArrowPaint.setStyle(Style.FILL_AND_STROKE);
        }
        if (TextPaint == null) {
            TextPaint = new Paint();
            TextPaint.setColor(ContextCompat.getColor(mContext,R.color.
yellowL));
            TextPaint.setTextSize(16);
            //txtPaint.setTypeface(lcd);
            TextPaint.setStyle(Style.FILL_AND_STROKE);
        }
        if (mPath == null) {
            mPath = new Path();
        } else {
            mPath.reset();
        }
        if (mRect == null) {
            mRect = new Rect();
        }


        if (BoxPaint2 == null) {
            BoxPaint2 = new Paint();
            BoxPaint2.setAntiAlias(true);
            BoxPaint2.setStrokeWidth(2.0f);
            //BoxPaint.setStyle(Style.STROKE);
            BoxPaint2.setStyle(Style.STROKE);
            BoxPaint2.setColor(ContextCompat.getColor(mContext,R.color.
bwff_9e));
        }


    }


    public static void InitDetectionArea() {
        try {
            int w = Prefe.DetectionArea.width();
            int h = Prefe.DetectionArea.height();
            int x = Prefe.DetectionArea.left;
            int y = Prefe.DetectionArea.top;


            // ver 2.6.0
            if (Prefe.DetectionArea.left == 1
                    && Prefe.DetectionArea.top == 1
                    && Prefe.DetectionArea.right == 1
                    && Prefe.DetectionArea.bottom == 1) {


                w = Prefe.DisplayWidth / 4;
                h = Prefe.DisplayHeight / 3;


                // ver 2.5.9
                w = Width / 4;
                h = Height / 3;


                Prefe.DetectorWidth = w;    //UtilGeneralHelper.GetDisplayPixel(this, 
100);
                Prefe.DetectorHeight = h;   //UtilGeneralHelper.GetDisplayPixel(this, 
100);


                x = (Prefe.DisplayWidth / 2) - (w / 2);
                y = (Prefe.DisplayHeight / 2) - (h / 2);


                // ver 2.5.9
                x = (Width / 2) - (w / 2);
                y = (Height / 2) - (h / 2);


            }


            //Prefe.DetectionArea = new Rect(x, x, x + Prefe.DetectorWidth, 
x + Prefe.DetectorHeight);
            Prefe.DetectionArea = new Rect(x, y, x + w, y + h);


            Prefe.gDetectionBitmapInt = new int[Prefe.DetectionArea.width() 
* Prefe.DetectionArea.height()];
            Prefe.gDetectionBitmapIntPrev = new int[Prefe.DetectionArea.
width() * Prefe.DetectionArea.height()];


        } catch (Exception e) {
            e.printStackTrace();
        }
    }


    public static void SetDetectionArea(int x, int y, int w, int h) {
        try {
            Prefe.DetectionArea = new Rect(x, y, w, h);


        } catch (Exception e) {
            e.printStackTrace();
        }
    }


    private void DrawAreaBox(Canvas canvas) {
        try {
        } catch (Exception e) {
            e.printStackTrace();
        }
    }


    @Override
    protected void dispatchDraw(Canvas canvas) {
        try {
            if (this.getRootView().isInEditMode()) {
                super.dispatchDraw(canvas);
                return;
            }


            //canvas.save(Canvas.MATRIX_SAVE_FLAG);
            //Prefe.DetectionAreaOrient = 
UtilGeneralHelper.GetDetectRectByOrientation();


            canvas.drawColor(0);
            mPath.reset();


            canvas.drawRect(Prefe.DetectionArea, BoxPaint);


            mPath.moveTo(Prefe.DetectionArea.right - ArrowWidth, Prefe.
DetectionArea.bottom);
            mPath.lineTo(Prefe.DetectionArea.right, Prefe.DetectionArea.bottom 
- ArrowWidth);
            mPath.lineTo(Prefe.DetectionArea.right, Prefe.DetectionArea.
bottom);
            mPath.lineTo(Prefe.DetectionArea.right - ArrowWidth, Prefe.
DetectionArea.bottom);
            mPath.close();
            canvas.drawPath(mPath, ArrowPaint);


            mPath.reset();
            //canvas.drawRect(Prefe.DetectionAreaOrient, BoxPaint2);
            //canvas.drawRect(Prefe.DetectionAreaOrientPort, BoxPaint2);


            TextPaint.setTextSize(16);
            //TextPaint.setLetterSpacing(2);


            TextPaint.setColor(ContextCompat.getColor(mContext,R.color.bwff
));


            TextPaint.getTextBounds(getResources().getString(R.string.
str_detectarea), 0, 1, mRect);
            canvas.drawText(getResources().getString(R.string.str_detectarea
),
                    Prefe.DetectionArea.left + 4,
                    Prefe.DetectionArea.top + 4 + mRect.height(),
                    TextPaint);
            int recH = mRect.height();


            TextPaint.setStrokeWidth(1.2f);
            TextPaint.setTextSize(18);
            TextPaint.setColor(ContextCompat.getColor(mContext,R.color.
redD_9e));
            TextPaint.getTextBounds(getResources().getString(R.string.
str_dragandmove), 0, 1, mRect);
            canvas.drawText(getResources().getString(R.string.
str_dragandmove),
                    Prefe.DetectionArea.left + 4,
                    Prefe.DetectionArea.top + 20 + mRect.height()*2,
                    TextPaint);


            TextPaint.getTextBounds(getResources().getString(R.string.
str_scalearea), 0, 1, mRect);
            canvas.drawText(getResources().getString(R.string.str_scalearea
),
                    Prefe.DetectionArea.left + 4,
                    Prefe.DetectionArea.top + 36 + mRect.height()*3,
                    TextPaint);


            super.dispatchDraw(canvas);
            //canvas.restore();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }


    @Override
    protected void onDraw(Canvas canvas) {
        try {
            super.onDraw(canvas);
            invalidate();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {


        }
    }


    @Override
    public boolean onTouchEvent(MotionEvent event) {
        boolean retValue = true;
        int X = (int)event.getX();
        int Y = (int)event.getY();






        //AppMain.txtLoc.setText(String.valueOf(X) + ", " + 
String.valueOf(Y));


        switch (event.getAction()) {
            case MotionEvent.ACTION_DOWN:
                mBoxTouched = TouchedInBoxArea(X, Y);


                //AppMain.txtLoc.setText("BoxTouched: " + 
String.valueOf(mBoxTouched));


                if (!mBoxTouched) break;


                lastX = X;
                lastY = Y;


                BoxPaint.setStyle(Style.FILL_AND_STROKE);
                BoxPaint.setColor(ContextCompat.getColor(mContext,R.color.
redD_9e));


                mArrowTouched = TouchedInArrow(X, Y);
                //AppMain.txtLoc.setText("ArrowTouched: " + 
String.valueOf(mBoxTouched));


                if (mArrowTouched) {
                    ArrowPaint.setColor(ContextCompat.getColor(mContext,R.
color.bwff_9e));
                }


                break;


            case MotionEvent.ACTION_MOVE:
                if (!mBoxTouched) break;


                int moveX = X - lastX;
                int moveY = Y - lastY;


                //AppMain.txtLoc.setText("Move X, Y: " + 
String.valueOf(moveX) + "," + String.valueOf(moveY));
                if (!mArrowTouched) {
                    if (Prefe.DetectionArea.left + moveX < 0) {
                        break;
                    }
    //     if (Prefe.DetectionArea.right + moveX > 
Prefe.gDisplay.getWidth()) {
    //     break;
    //     }
                    // ver 2.5.9
                    if (Prefe.DetectionArea.right + moveX > Width) {
                        break;
                    }
                    if (Prefe.DetectionArea.top + moveY < 0) {
                        break;
                    }
    //     if (Prefe.DetectionArea.bottom + moveY > 
Prefe.gDisplay.getHeight()) {
    //     break;
    //     }
                    // ver 2.5.9
                    if (Prefe.DetectionArea.bottom + moveY > Height) {
                        break;
                    }
                }


                if (mArrowTouched) {
                    if ((Prefe.DetectionArea.width() + moveX) < ArrowWidth * 
2){
                        break;
                    }
                    if ((Prefe.DetectionArea.height() + moveY) < ArrowWidth 
* 2) {
                        break;
                    }
                    Prefe.DetectionArea.right += moveX;
                    Prefe.DetectionArea.bottom += moveY;
                    //Log.i("DBG", "W,H: " + 
String.valueOf(Prefe.DetectionArea.width()) + "," + 
String.valueOf(Prefe.DetectionArea.height()));
                } else {
                    Prefe.DetectionArea.left += moveX;
                    Prefe.DetectionArea.right += moveX;
                    Prefe.DetectionArea.top += moveY;
                    Prefe.DetectionArea.bottom += moveY;
                }


                lastX = X;
                lastY = Y;


                //AppMain.txtLoc.setText(String.valueOf(Prefe.DetectionArea.left) 
+ ", " + String.valueOf(Prefe.DetectionArea.top));
                break;


            case MotionEvent.ACTION_UP:
                mBoxTouched = false;
                mArrowTouched = false;
                //BoxPaint.setStyle(Style.STROKE);
                BoxPaint.setStyle(Style.FILL_AND_STROKE);
                BoxPaint.setColor(ContextCompat.getColor(mContext,R.color.
bwff_60));
                ArrowPaint.setColor(ContextCompat.getColor(mContext,R.color.
redDD));


                //AppMain.txtLoc.setText(String.valueOf(Prefe.DetectionArea.left) 
+ ", " + String.valueOf(Prefe.DetectionArea.top));


                if (Prefe.DetectionArea.left < 0) {
                    Prefe.DetectionArea.left = 0;
                }
    //     if (Prefe.DetectionArea.right > Prefe.gDisplay.getWidth()) {
    //     Prefe.DetectionArea.right = Prefe.gDisplay.getWidth();
    //     }
                // ver 2.5.9
                if (Prefe.DetectionArea.right > Width) {
                    Prefe.DetectionArea.right = Width;
                }
                if (Prefe.DetectionArea.top < 0) {
                    Prefe.DetectionArea.top = 0;
                }
    //     if (Prefe.DetectionArea.bottom > Prefe.gDisplay.getHeight()) {
    //     Prefe.DetectionArea.bottom = Prefe.gDisplay.getHeight();
    //     }
                if (Prefe.DetectionArea.bottom > Height) {
                    Prefe.DetectionArea.bottom = Height;
                }


                Prefe.gDetectionBitmapInt = new int[Prefe.DetectionArea.
width() * Prefe.DetectionArea.height()];
                Prefe.gDetectionBitmapIntPrev = new int[Prefe.DetectionArea.
width() * Prefe.DetectionArea.height()];
                //Prefe.gDetectionBitmapInt = null;
                //Prefe.gDetectionBitmapIntPrev = null;


                String area = String.valueOf(Prefe.DetectionArea.left)
                        + "," + String.valueOf(Prefe.DetectionArea.top)
                        + "," + String.valueOf(Prefe.DetectionArea.right)
                        + "," + String.valueOf(Prefe.DetectionArea.bottom);


               // UtilGeneralHelper.SavePreferenceSetting(Prefe.gContext, 
Prefe.PREF_DETECTION_AREA_KEY, area);
                //Saving the value
                SharedPrefsUtils.setStringPreference(mContext.
getApplicationContext(), Prefe.PREF_DETECTION_AREA_KEY, area);
                Log.v("TAG", SharedPrefsUtils.getStringPreference(mContext.
getApplicationContext(),Prefe.PREF_DETECTION_AREA_KEY));




                break;
        }


        invalidate();
        return retValue;
    }


    private boolean TouchedInBoxArea(int x, int y) {
        boolean retValue = false;
        try {


            if (x > Prefe.DetectionArea.left && x < Prefe.DetectionArea.
right) {
                if (y > Prefe.DetectionArea.top && y < Prefe.DetectionArea.
bottom) {
                    retValue = true;
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return retValue;
    }


    private boolean TouchedInArrow(int x, int y) {
        boolean retValue = false;
        try {


            if (x > Prefe.DetectionArea.right - ArrowWidth && x < Prefe.
DetectionArea.right) {
                if (y > Prefe.DetectionArea.bottom - ArrowWidth && y < Prefe
.DetectionArea.bottom) {
                    retValue = true;
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return retValue;
    }


    @Override
    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
        super.onMeasure(widthMeasureSpec, heightMeasureSpec);
        int width = MeasureSpec.getSize(widthMeasureSpec);
        int height = MeasureSpec.getSize(heightMeasureSpec);
        setMeasuredDimension(width, height);
        Width = width;
        Height = height;
        InitDetectionArea();
    }


    @Override
    protected void onFinishInflate() {
        super.onFinishInflate();
    }


    @Override
    protected void onLayout(boolean changed, int l, int t, int r, int b) {
        // TODO Auto-generated method stub
        for (int i = 0; i < this.getChildCount()-1; i++){
            (this.getChildAt(i)).layout(l, t, r, b);
        }


        if (changed) {
            // check width height
            if (r != Width || b != Height) {
                // size does not match
            }
        }
    }
    }

*Prefe.java*

    
public class Prefe extends Application{
    ...
    public static final String PREF_DETECTION_AREA_KEY = 
"pref_detection_area_key";
    }
    static{
    ...
    DetectionArea = new Rect(1, 1, 1, 1);
    }
    }



-- 
You received this message because you are subscribed to the Google Groups "Android Developers" group.
To unsubscribe from this group and stop receiving emails from it, send an email to android-developers+unsubscribe@xxxxxxxxxxxxxxxx.
To post to this group, send email to android-developers@xxxxxxxxxxxxxxxx.
Visit this group at https://groups.google.com/group/android-developers.
To view this discussion on the web visit https://groups.google.com/d/msgid/android-developers/75ec72f3-7d44-4231-89f4-41e1ae4f7dec%40googlegroups.com.
For more options, visit https://groups.google.com/d/optout.
<Anterior por Tema] Tema Actual [Siguiente por Tema>
  • [android-developers] Cómo a cultivo bitmaps según medida de una vista de costumbre para especificar el área de detección de movimiento, Dioptre Pic <=