Autore Topic: Riconoscimento forme da fotocamera  (Letto 4984 volte)

Offline Fuma

  • Nuovo arrivato
  • *
  • Post: 11
  • Respect: 0
    • Mostra profilo
Riconoscimento forme da fotocamera
« il: 09 Febbraio 2012, 10:31:13 CET »
0
Salve a tutti mi piacerebbe fare un'app che riconosce delle forme geometriche disegnate su un foglio,una lavagna ecc.. Semplicemente scattando una foto.Per quanto riguarda l'ottenere l'immagine dalla fotocamera ho visto già molti tutorial su questo forum per quanto riguarda invece il riconoscimento di forme,lettere ecc...  C'è qualche API da cui partire? o Se qualcuno di voi conoscesse dei tutorial sull'argomento,libri o comunque un punto di partenza e potesse suggerirmelo gliene sarei grato.

Offline iceweasel

  • Moderatore globale
  • Utente senior
  • *****
  • Post: 878
  • Respect: +147
    • Mostra profilo
  • Dispositivo Android:
    LGE P990 - Google Nexus 5
  • Sistema operativo:
    Linux Debian Sid
Re:Riconoscimento forme da fotocamera
« Risposta #1 il: 09 Febbraio 2012, 11:48:16 CET »
+2
Le OpenCV implementano metodi per il riconoscimento delle forme geometriche:

http://opencv.willowgarage.com/documentation/cpp/structural_analysis_and_shape_descriptors.html

Esiste il porting per Android:

http://opencv.itseez.com/doc/tutorials/introduction/android_binary_package/android_binary_package.html

non sono facili da usare, si utilizza NDK e servono delle buoni basi sul digital image processing.
adb logcat | tee /tmp/logcat | grep TAG

Offline denper

  • Utente normale
  • ***
  • Post: 290
  • Respect: +60
    • Mostra profilo
    • Anddenper
  • Dispositivo Android:
    Moto G
  • Play Store ID:
    denper
  • Sistema operativo:
    Window 7, Windows XP
Re:Riconoscimento forme da fotocamera
« Risposta #2 il: 09 Febbraio 2012, 13:55:44 CET »
+2
Ciao,
un'altra libreria di image processing che posso consigliarti è Jon's Java Imaging Library, la puoi trovare qui. Con questa non c'è la necessità di utilizzare NDK, ovviamente anche in questo caso devi avere le basi di digital image processing. Se il tuo obbiettivo è quello di riconoscere delle forme geometriche uno dei primi problemi da affrontare è quello di eseguire il riconoscimento dei bordi. Mi sono permesso di creare un mini progetto dove c'è un esempio di edges detection usando l'argoritmo di Canny Edge Detector (http://en.wikipedia.org/wiki/Canny_edge_detector). Potrebbe esserti utile come punto di partenza...

Creati un progetto è aggiungi queste 2 classi, il layout e un'immagine di prova (test_image) nella cartella drawable. Visto che è un test ti consiglio di utilizzare un'immagine di dimensioni ridotte e con una buona qualità. L'esempio serve solo per farti capire le logiche dell'algoritmo. Giocando sui parametri lowThreshold, highThreshold, gaussianKernelRadius, gaussianKernelWidth e contrastNormalized puoi affinare il risultato in base all'immagine di ingresso. Inizialmente usa quelli pre-impostati.

CannyEdgeDetector.java

Codice (Java): [Seleziona]
package it.example.cannyedgedetector;

import java.util.Arrays;

import android.graphics.Bitmap;

public class CannyEdgeDetector {
        // statics

        private final static float GAUSSIAN_CUT_OFF = 0.005f;
        private final static float MAGNITUDE_SCALE = 100F;
        private final static float MAGNITUDE_LIMIT = 1000F;
        private final static int MAGNITUDE_MAX = (int) (MAGNITUDE_SCALE * MAGNITUDE_LIMIT);

        // fields

        private int height;
        private int width;
        private int picsize;
        private int[] data;
        private int[] magnitude;
        private Bitmap sourceImage;
        private Bitmap edgesImage;

        private float gaussianKernelRadius;
        private float lowThreshold;
        private float highThreshold;
        private int gaussianKernelWidth;
        private boolean contrastNormalized;

        private float[] xConv;
        private float[] yConv;
        private float[] xGradient;
        private float[] yGradient;

        // constructors

        /**
         * Constructs a new detector with default parameters.
         */


        public CannyEdgeDetector() {
                lowThreshold = 2.5f;
                highThreshold = 7.5f;
                gaussianKernelRadius = 2f;
                gaussianKernelWidth = 16;
                contrastNormalized = false;
        }

        // accessors

        /**
         * The image that provides the luminance data used by this detector to
         * generate edges.
         *
         * @return the source image, or null
         */


        public Bitmap getSourceImage() {
                return sourceImage;
        }

        /**
         * Specifies the image that will provide the luminance data in which edges
         * will be detected. A source image must be set before the process method is
         * called.
         *
         * @param image
         *            a source of luminance data
         */


        public void setSourceImage(Bitmap image) {
                sourceImage = image;
        }

        /**
         * Obtains an image containing the edges detected during the last call to
         * the process method. The buffered image is an opaque image of type
         * BufferedImage.TYPE_INT_ARGB in which edge pixels are white and all other
         * pixels are black.
         *
         * @return an image containing the detected edges, or null if the process
         *         method has not yet been called.
         */


        public Bitmap getEdgesImage() {
                return edgesImage;
        }

        /**
         * Sets the edges image. Calling this method will not change the operation
         * of the edge detector in any way. It is intended to provide a means by
         * which the memory referenced by the detector object may be reduced.
         *
         * @param edgesImage
         *            expected (though not required) to be null
         */


        public void setEdgesImage(Bitmap edgesImage) {
                this.edgesImage = edgesImage;
        }

        /**
         * The low threshold for hysteresis. The default value is 2.5.
         *
         * @return the low hysteresis threshold
         */


        public float getLowThreshold() {
                return lowThreshold;
        }

        /**
         * Sets the low threshold for hysteresis. Suitable values for this parameter
         * must be determined experimentally for each application. It is nonsensical
         * (though not prohibited) for this value to exceed the high threshold
         * value.
         *
         * @param threshold
         *            a low hysteresis threshold
         */


        public void setLowThreshold(float threshold) {
                if (threshold < 0)
                        throw new IllegalArgumentException();
                lowThreshold = threshold;
        }

        /**
         * The high threshold for hysteresis. The default value is 7.5.
         *
         * @return the high hysteresis threshold
         */


        public float getHighThreshold() {
                return highThreshold;
        }

        /**
         * Sets the high threshold for hysteresis. Suitable values for this
         * parameter must be determined experimentally for each application. It is
         * nonsensical (though not prohibited) for this value to be less than the
         * low threshold value.
         *
         * @param threshold
         *            a high hysteresis threshold
         */


        public void setHighThreshold(float threshold) {
                if (threshold < 0)
                        throw new IllegalArgumentException();
                highThreshold = threshold;
        }

        /**
         * The number of pixels across which the Gaussian kernel is applied. The
         * default value is 16.
         *
         * @return the radius of the convolution operation in pixels
         */


        public int getGaussianKernelWidth() {
                return gaussianKernelWidth;
        }

        /**
         * The number of pixels across which the Gaussian kernel is applied. This
         * implementation will reduce the radius if the contribution of pixel values
         * is deemed negligable, so this is actually a maximum radius.
         *
         * @param gaussianKernelWidth
         *            a radius for the convolution operation in pixels, at least 2.
         */


        public void setGaussianKernelWidth(int gaussianKernelWidth) {
                if (gaussianKernelWidth < 2)
                        throw new IllegalArgumentException();
                this.gaussianKernelWidth = gaussianKernelWidth;
        }

        /**
         * The radius of the Gaussian convolution kernel used to smooth the source
         * image prior to gradient calculation. The default value is 16.
         *
         * @return the Gaussian kernel radius in pixels
         */


        public float getGaussianKernelRadius() {
                return gaussianKernelRadius;
        }

        /**
         * Sets the radius of the Gaussian convolution kernel used to smooth the
         * source image prior to gradient calculation.
         *
         * @return a Gaussian kernel radius in pixels, must exceed 0.1f.
         */


        public void setGaussianKernelRadius(float gaussianKernelRadius) {
                if (gaussianKernelRadius < 0.1f)
                        throw new IllegalArgumentException();
                this.gaussianKernelRadius = gaussianKernelRadius;
        }

        /**
         * Whether the luminance data extracted from the source image is normalized
         * by linearizing its histogram prior to edge extraction. The default value
         * is false.
         *
         * @return whether the contrast is normalized
         */


        public boolean isContrastNormalized() {
                return contrastNormalized;
        }

        /**
         * Sets whether the contrast is normalized
         *
         * @param contrastNormalized
         *            true if the contrast should be normalized, false otherwise
         */


        public void setContrastNormalized(boolean contrastNormalized) {
                this.contrastNormalized = contrastNormalized;
        }

        // methods

        public void process() {
                width = sourceImage.getWidth();
                height = sourceImage.getHeight();
                picsize = width * height;
                initArrays();
                readLuminance();
                if (contrastNormalized)
                        normalizeContrast();
                computeGradients(gaussianKernelRadius, gaussianKernelWidth);
                int low = Math.round(lowThreshold * MAGNITUDE_SCALE);
                int high = Math.round(highThreshold * MAGNITUDE_SCALE);
                performHysteresis(low, high);
                thresholdEdges();
                writeEdges(data);
        }

        // private utility methods

        private void initArrays() {
                if (data == null || picsize != data.length) {
                        data = new int[picsize];
                        magnitude = new int[picsize];

                        xConv = new float[picsize];
                        yConv = new float[picsize];
                        xGradient = new float[picsize];
                        yGradient = new float[picsize];
                }
        }

        // NOTE: The elements of the method below (specifically the technique for
        // non-maximal suppression and the technique for gradient computation)
        // are derived from an implementation posted in the following forum (with
        // the
        // clear intent of others using the code):
        // http://forum.java.sun.com/thread.jspa?threadID=546211&start=45&tstart=0
        // My code effectively mimics the algorithm exhibited above.
        // Since I don't know the providence of the code that was posted it is a
        // possibility (though I think a very remote one) that this code violates
        // someone's intellectual property rights. If this concerns you feel free to
        // contact me for an alternative, though less efficient, implementation.

        private void computeGradients(float kernelRadius, int kernelWidth) {

                // generate the gaussian convolution masks
                float kernel[] = new float[kernelWidth];
                float diffKernel[] = new float[kernelWidth];
                int kwidth;
                for (kwidth = 0; kwidth < kernelWidth; kwidth++) {
                        float g1 = gaussian(kwidth, kernelRadius);
                        if (g1 <= GAUSSIAN_CUT_OFF && kwidth >= 2)
                                break;
                        float g2 = gaussian(kwidth - 0.5f, kernelRadius);
                        float g3 = gaussian(kwidth + 0.5f, kernelRadius);
                        kernel[kwidth] = (g1 + g2 + g3) / 3f / (2f * (float) Math.PI * kernelRadius * kernelRadius);
                        diffKernel[kwidth] = g3 - g2;
                }

                int initX = kwidth - 1;
                int maxX = width - (kwidth - 1);
                int initY = width * (kwidth - 1);
                int maxY = width * (height - (kwidth - 1));

                // perform convolution in x and y directions
                for (int x = initX; x < maxX; x++) {
                        for (int y = initY; y < maxY; y += width) {
                                int index = x + y;
                                float sumX = data[index] * kernel[0];
                                float sumY = sumX;
                                int xOffset = 1;
                                int yOffset = width;
                                for (; xOffset < kwidth;) {
                                        sumY += kernel[xOffset] * (data[index - yOffset] + data[index + yOffset]);
                                        sumX += kernel[xOffset] * (data[index - xOffset] + data[index + xOffset]);
                                        yOffset += width;
                                        xOffset++;
                                }

                                yConv[index] = sumY;
                                xConv[index] = sumX;
                        }

                }

                for (int x = initX; x < maxX; x++) {
                        for (int y = initY; y < maxY; y += width) {
                                float sum = 0f;
                                int index = x + y;
                                for (int i = 1; i < kwidth; i++)
                                        sum += diffKernel[i] * (yConv[index - i] - yConv[index + i]);

                                xGradient[index] = sum;
                        }

                }

                for (int x = kwidth; x < width - kwidth; x++) {
                        for (int y = initY; y < maxY; y += width) {
                                float sum = 0.0f;
                                int index = x + y;
                                int yOffset = width;
                                for (int i = 1; i < kwidth; i++) {
                                        sum += diffKernel[i] * (xConv[index - yOffset] - xConv[index + yOffset]);
                                        yOffset += width;
                                }

                                yGradient[index] = sum;
                        }

                }

                initX = kwidth;
                maxX = width - kwidth;
                initY = width * kwidth;
                maxY = width * (height - kwidth);
                for (int x = initX; x < maxX; x++) {
                        for (int y = initY; y < maxY; y += width) {
                                int index = x + y;
                                int indexN = index - width;
                                int indexS = index + width;
                                int indexW = index - 1;
                                int indexE = index + 1;
                                int indexNW = indexN - 1;
                                int indexNE = indexN + 1;
                                int indexSW = indexS - 1;
                                int indexSE = indexS + 1;

                                float xGrad = xGradient[index];
                                float yGrad = yGradient[index];
                                float gradMag = hypot(xGrad, yGrad);

                                // perform non-maximal supression
                                float nMag = hypot(xGradient[indexN], yGradient[indexN]);
                                float sMag = hypot(xGradient[indexS], yGradient[indexS]);
                                float wMag = hypot(xGradient[indexW], yGradient[indexW]);
                                float eMag = hypot(xGradient[indexE], yGradient[indexE]);
                                float neMag = hypot(xGradient[indexNE], yGradient[indexNE]);
                                float seMag = hypot(xGradient[indexSE], yGradient[indexSE]);
                                float swMag = hypot(xGradient[indexSW], yGradient[indexSW]);
                                float nwMag = hypot(xGradient[indexNW], yGradient[indexNW]);
                                float tmp;
                                /*
                                 * An explanation of what's happening here, for those who want
                                 * to understand the source: This performs the "non-maximal
                                 * supression" phase of the Canny edge detection in which we
                                 * need to compare the gradient magnitude to that in the
                                 * direction of the gradient; only if the value is a local
                                 * maximum do we consider the point as an edge candidate.
                                 *
                                 * We need to break the comparison into a number of different
                                 * cases depending on the gradient direction so that the
                                 * appropriate values can be used. To avoid computing the
                                 * gradient direction, we use two simple comparisons: first we
                                 * check that the partial derivatives have the same sign (1) and
                                 * then we check which is larger (2). As a consequence, we have
                                 * reduced the problem to one of four identical cases that each
                                 * test the central gradient magnitude against the values at two
                                 * points with 'identical support'; what this means is that the
                                 * geometry required to accurately interpolate the magnitude of
                                 * gradient function at those points has an identical geometry
                                 * (upto right-angled-rotation/reflection).
                                 *
                                 * When comparing the central gradient to the two interpolated
                                 * values, we avoid performing any divisions by multiplying both
                                 * sides of each inequality by the greater of the two partial
                                 * derivatives. The common comparand is stored in a temporary
                                 * variable (3) and reused in the mirror case (4).
                                 */

                                if (xGrad * yGrad <= (float) 0 /* (1) */
                                ? Math.abs(xGrad) >= Math.abs(yGrad) /* (2) */
                                ? (tmp = Math.abs(xGrad * gradMag)) >= Math.abs(yGrad * neMag - (xGrad + yGrad) * eMag) /*
                                                                                                                                                                                                                 * (3
                                                                                                                                                                                                                 * )
                                                                                                                                                                                                                 */

                                                && tmp > Math.abs(yGrad * swMag - (xGrad + yGrad) * wMag) /*
                                                                                                                                                                 * (4
                                                                                                                                                                 * )
                                                                                                                                                                 */

                                : (tmp = Math.abs(yGrad * gradMag)) >= Math.abs(xGrad * neMag - (yGrad + xGrad) * nMag) /*
                                                                                                                                                                                                                 * (3
                                                                                                                                                                                                                 * )
                                                                                                                                                                                                                 */

                                                && tmp > Math.abs(xGrad * swMag - (yGrad + xGrad) * sMag) /*
                                                                                                                                                                 * (4
                                                                                                                                                                 * )
                                                                                                                                                                 */

                                : Math.abs(xGrad) >= Math.abs(yGrad) /* (2) */
                                ? (tmp = Math.abs(xGrad * gradMag)) >= Math.abs(yGrad * seMag + (xGrad - yGrad) * eMag) /*
                                                                                                                                                                                                                 * (3
                                                                                                                                                                                                                 * )
                                                                                                                                                                                                                 */

                                                && tmp > Math.abs(yGrad * nwMag + (xGrad - yGrad) * wMag) /*
                                                                                                                                                                 * (4
                                                                                                                                                                 * )
                                                                                                                                                                 */

                                : (tmp = Math.abs(yGrad * gradMag)) >= Math.abs(xGrad * seMag + (yGrad - xGrad) * sMag) /*
                                                                                                                                                                                                                 * (3
                                                                                                                                                                                                                 * )
                                                                                                                                                                                                                 */

                                                && tmp > Math.abs(xGrad * nwMag + (yGrad - xGrad) * nMag) /*
                                                                                                                                                                 * (4
                                                                                                                                                                 * )
                                                                                                                                                                 */

                                ) {
                                        magnitude[index] = gradMag >= MAGNITUDE_LIMIT ? MAGNITUDE_MAX : (int) (MAGNITUDE_SCALE * gradMag);
                                        // NOTE: The orientation of the edge is not employed by this
                                        // implementation. It is a simple matter to compute it at
                                        // this point as: Math.atan2(yGrad, xGrad);
                                } else {
                                        magnitude[index] = 0;
                                }
                        }
                }
        }

        // NOTE: It is quite feasible to replace the implementation of this method
        // with one which only loosely approximates the hypot function. I've tested
        // simple approximations such as Math.abs(x) + Math.abs(y) and they work
        // fine.
        private float hypot(float x, float y) {
                return (float) Math.hypot(x, y);
        }

        private float gaussian(float x, float sigma) {
                return (float) Math.exp(-(x * x) / (2f * sigma * sigma));
        }

        private void performHysteresis(int low, int high) {
                // NOTE: this implementation reuses the data array to store both
                // luminance data from the image, and edge intensity from the
                // processing.
                // This is done for memory efficiency, other implementations may wish
                // to separate these functions.
                Arrays.fill(data, 0);

                int offset = 0;
                for (int y = 0; y < height; y++) {
                        for (int x = 0; x < width; x++) {
                                if (data[offset] == 0 && magnitude[offset] >= high) {
                                        follow(x, y, offset, low);
                                }
                                offset++;
                        }
                }
        }

        private void follow(int x1, int y1, int i1, int threshold) {
                int x0 = x1 == 0 ? x1 : x1 - 1;
                int x2 = x1 == width - 1 ? x1 : x1 + 1;
                int y0 = y1 == 0 ? y1 : y1 - 1;
                int y2 = y1 == height - 1 ? y1 : y1 + 1;

                data[i1] = magnitude[i1];
                for (int x = x0; x <= x2; x++) {
                        for (int y = y0; y <= y2; y++) {
                                int i2 = x + y * width;
                                if ((y != y1 || x != x1) && data[i2] == 0 && magnitude[i2] >= threshold) {
                                        follow(x, y, i2, threshold);
                                        return;
                                }
                        }
                }
        }

        private void thresholdEdges() {
                for (int i = 0; i < picsize; i++) {
                        data[i] = data[i] > 0 ? -1 : 0xff000000;
                }
        }

        private int luminance(float r, float g, float b) {
                return Math.round(0.299f * r + 0.587f * g + 0.114f * b);
        }

        private void readLuminance() {

                int[] pixels = new int[height * width];
                sourceImage.getPixels(pixels, 0, width, 0, 0, width, height);
                for (int i = 0; i < picsize; i++) {
                        int p = pixels[i];
                        int r = (p & 0xff0000) >> 16;
                        int g = (p & 0xff00) >> 8;
                        int b = p & 0xff;
                        data[i] = luminance(r, g, b);
                }

        }

        private void normalizeContrast() {
                int[] histogram = new int[256];
                for (int i = 0; i < data.length; i++) {
                        histogram[data[i]]++;
                }
                int[] remap = new int[256];
                int sum = 0;
                int j = 0;
                for (int i = 0; i < histogram.length; i++) {
                        sum += histogram[i];
                        int target = sum * 255 / picsize;
                        for (int k = j + 1; k <= target; k++) {
                                remap[k] = i;
                        }
                        j = target;
                }

                for (int i = 0; i < data.length; i++) {
                        data[i] = remap[data[i]];
                }
        }

        private void writeEdges(int pixels[]) {
                // NOTE: There is currently no mechanism for obtaining the edge data
                // in any other format other than an INT_ARGB type BufferedImage.
                // This may be easily remedied by providing alternative accessors.
                if (edgesImage == null) {
                        edgesImage = Bitmap.createBitmap(pixels, width, height, Bitmap.Config.ARGB_8888);
                }
        }
}

CannyEdgeDetectorActivity.java

Codice (Java): [Seleziona]
package it.example.cannyedgedetector;

import android.app.Activity;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.os.AsyncTask;
import android.os.Bundle;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.ImageView;
import android.widget.ProgressBar;

public class CannyEdgeDetectorActivity extends Activity {
        private Button buttonDetect;
        private CannyEdgeDetector mCannyEdgeDetector;
        private Bitmap sourceImage;
        private Bitmap destinationImage;
        private ImageView destinationImageView;

        /** Called when the activity is first created. */
        @Override
        public void onCreate(Bundle savedInstanceState) {
                super.onCreate(savedInstanceState);
                setContentView(R.layout.main);
                sourceImage = BitmapFactory.decodeResource(getResources(), R.drawable.test_image);
                mCannyEdgeDetector = new CannyEdgeDetector();
                mCannyEdgeDetector.setLowThreshold(0.5f);
                mCannyEdgeDetector.setHighThreshold(1f);
                mCannyEdgeDetector.setSourceImage(sourceImage);

                destinationImageView = (ImageView) findViewById(R.id.destinationImage);

                buttonDetect = (Button) findViewById(R.id.buttonDetect);
                buttonDetect.setOnClickListener(new OnClickListener() {

                        @Override
                        public void onClick(View arg0) {
                                buttonDetect.setEnabled(false);
                                new DetectEdgesTask().execute(sourceImage);
                        }
                });

        }

        private class DetectEdgesTask extends AsyncTask<Bitmap, Void, Bitmap> {

                protected ProgressBar progressBarIndetermined;

                @Override
                protected void onPreExecute() {
                        super.onPreExecute();
                        progressBarIndetermined = (ProgressBar) findViewById(R.id.progressBarIndetermined);
                        destinationImageView.setVisibility(View.GONE);
                        progressBarIndetermined.setVisibility(View.VISIBLE);
                        mCannyEdgeDetector = new CannyEdgeDetector();
                        mCannyEdgeDetector.setLowThreshold(0.5f);
                        mCannyEdgeDetector.setHighThreshold(1f);

                }

                @Override
                protected Bitmap doInBackground(Bitmap... params) {
                        mCannyEdgeDetector.setSourceImage(params[0]);
                        mCannyEdgeDetector.process();
                        Bitmap result = mCannyEdgeDetector.getEdgesImage();
                        return result;
                }

                @Override
                protected void onPostExecute(Bitmap result) {
                        super.onPostExecute(result);
                        destinationImageView.setImageBitmap(result);
                        destinationImageView.setVisibility(View.VISIBLE);
                        buttonDetect.setEnabled(true);
                        progressBarIndetermined.setVisibility(View.GONE);
                };

        }
}

Layout main.xml

Codice (XML): [Seleziona]
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
   android:layout_width="fill_parent"
   android:layout_height="fill_parent"
   android:orientation="vertical" >

    <TextView
       android:layout_width="fill_parent"
       android:layout_height="wrap_content"
       android:text="CannyEdgeDetector" />

    <ImageView
       android:id="@+id/sourceImage"
       android:layout_width="wrap_content"
       android:layout_height="wrap_content"
       android:src="@drawable/test_image" />

    <Button
       android:id="@+id/buttonDetect"
       android:layout_width="wrap_content"
       android:layout_height="wrap_content"
       android:text="Detect Edges" />

    <ProgressBar
       android:id="@+id/progressBarIndetermined"
       android:layout_width="wrap_content"
       android:layout_height="wrap_content" android:visibility="gone"/>


    <ImageView
       android:id="@+id/destinationImage"
       android:layout_width="wrap_content"
       android:layout_height="wrap_content"
       android:src="@drawable/ic_launcher" android:visibility="gone"/>

</LinearLayout>

Saluti.
Tutti sanno che una cosa è impossibile da realizzare, finché arriva uno sprovveduto che non lo sa e la inventa. [A.Einstein]

Proteggi la tua privacy! Utilizza GhostPhone! https://play.google.com/store/apps/details?id=com.denper.gp
Giochi a Winforlife e Superenalotto e sei stanco di controllare le tue schedine manualmente? Prova Checkwin: https://play.google.com/store/apps/details?id=com.denper.checkwintrial

Offline Fuma

  • Nuovo arrivato
  • *
  • Post: 11
  • Respect: 0
    • Mostra profilo
Re:Riconoscimento forme da fotocamera
« Risposta #3 il: 09 Febbraio 2012, 19:13:23 CET »
0
Grazie mille delle risposte premetto di non conoscere molto di digital image processing ma ringrazio infinitamente entrambi per avermi dato dei punti di partenza (prima ero proprio spaesato). Adesso inizierò a leggermi con calma la documentazione delle OpenCV che dovrebbero avere buone prestazioni essendo scritte in C++ e a capire qualcosa dell'algoritmo di Canny grazie ancora di tutto  :D

Offline Fuma

  • Nuovo arrivato
  • *
  • Post: 11
  • Respect: 0
    • Mostra profilo
Re:Riconoscimento forme da fotocamera
« Risposta #4 il: 09 Febbraio 2012, 19:22:36 CET »
0
Ancora una domanda per caso conoscete qualche buon tutorial o libro delle OpenCV in Italiano?

Offline iceweasel

  • Moderatore globale
  • Utente senior
  • *****
  • Post: 878
  • Respect: +147
    • Mostra profilo
  • Dispositivo Android:
    LGE P990 - Google Nexus 5
  • Sistema operativo:
    Linux Debian Sid
Re:Riconoscimento forme da fotocamera
« Risposta #5 il: 09 Febbraio 2012, 20:22:35 CET »
0
Credo di non aver mai visto nulla in Italiano sulle OpenCV. Per programmare bisogna conoscere un minimo di Inglese tecnico.

Il sito nelle OpenCV contiene un elenco di documentazione (in Inglese) disponibile:

FullOpenCVWiki - OpenCV Wiki
adb logcat | tee /tmp/logcat | grep TAG

Offline Fuma

  • Nuovo arrivato
  • *
  • Post: 11
  • Respect: 0
    • Mostra profilo
Re:Riconoscimento forme da fotocamera
« Risposta #6 il: 13 Febbraio 2012, 21:20:32 CET »
0
Rispondo ancora a questo post perchè dopo aver provato qualche esempio delle opencv ho qualche dubbio e avendo trovato persone competenti confido nella loro pazienza ;-) Sono riuscito a visualizzare con la funzione cvCanny i contorni di un'immagine e trovare anche i parametri adatti ora se punto la telecamera su un foglio con disegnato un triangolo vedo i contorni del triangolo in bianco ed il resto nero, il mio dubbio arriva ora per rilevare le varie,forme,lettere ecc devo prendermi i pixel bianchi e tramite le loro coordinate costruirmi io un algoritmo che "capisca" che si tratti di un triangolo e che gli altri contorni bianchi non vogliano dire niente o c'è ancora qualche funzione della libreria che può tornarmi utile? Ho spulciato un po' la documentazione e fatto un po' di test con scarsi risultati...

Offline iceweasel

  • Moderatore globale
  • Utente senior
  • *****
  • Post: 878
  • Respect: +147
    • Mostra profilo
  • Dispositivo Android:
    LGE P990 - Google Nexus 5
  • Sistema operativo:
    Linux Debian Sid
Re:Riconoscimento forme da fotocamera
« Risposta #7 il: 13 Febbraio 2012, 21:58:52 CET »
0
Studiati gli esempi presenti nei sorgenti delle OpenCV, ad esempio "squares" individua forme rettangolari, "fitellipse" per forme ellittiche.
adb logcat | tee /tmp/logcat | grep TAG