Gambarlah lingkaran yang sempurna dari sentuhan pengguna

Saya memiliki proyek latihan ini yang memungkinkan pengguna untuk menggambar di layar saat mereka menyentuh dengan jari-jari mereka. App yang sangat sederhana saya lakukan sebagai latihan jalan kembali. Sepupu kecil saya mengambil kebebasan menggambar dengan jarinya dengan iPad saya di Aplikasi ini (Gambar anak-anak: lingkaran, garis, dll, apa pun yang terlintas dalam pikirannya). Kemudian dia mulai menggambar lingkaran dan kemudian dia meminta saya untuk menjadikannya "lingkaran yang baik" (dari pemahaman saya: membuat lingkaran yang digambar menjadi bulat sempurna, seperti yang kita ketahui tidak masalah seberapa stabil kita mencoba menggambar sesuatu dengan jari kita di layar, sebuah lingkaran tidak pernah benar-benar bulat seperti seharusnya lingkaran).

Jadi pertanyaan saya di sini adalah, apakah ada cara dalam kode di mana kita pertama kali dapat mendeteksi garis yang ditarik oleh pengguna yang membentuk lingkaran dan menghasilkan ukuran lingkaran yang kira-kira sama dengan membuatnya bulat sempurna di layar. Membuat garis yang tidak terlalu lurus adalah sesuatu yang saya tahu caranya, tetapi untuk lingkaran, saya tidak tahu bagaimana cara melakukannya dengan Quartz atau metode lain.

Alasan saya adalah bahwa, titik awal dan akhir dari garis harus menyentuh atau saling silang setelah pengguna mengangkat jarinya untuk membenarkan fakta bahwa ia mencoba untuk benar-benar menggambar lingkaran.

Terkadang sangat berguna untuk meluangkan waktu menciptakan kembali roda. Seperti yang mungkin sudah Anda perhatikan ada banyak kerangka kerja, tetapi tidak sulit untuk mengimplementasikan solusi sederhana, namun bermanfaat tanpa memperkenalkan semua kompleksitas itu. (Tolong jangan salah paham, untuk tujuan serius apa pun lebih baik menggunakan kerangka kerja yang matang dan terbukti stabil).

Saya akan mempresentasikan hasil saya pertama dan kemudian menjelaskan ide sederhana dan langsung di belakang mereka.

Anda akan melihat dalam implementasi saya tidak perlu menganalisis setiap titik dan melakukan perhitungan yang kompleks. Idenya adalah untuk menemukan beberapa informasi meta yang berharga. Saya akan menggunakan tangen sebagai contoh:

Mari kita identifikasi pola yang sederhana dan langsung, khas untuk bentuk yang dipilih:

Jadi tidak sulit untuk menerapkan mekanisme deteksi lingkaran berdasarkan ide itu. Lihat demo yang berfungsi di bawah ini (Maaf, saya menggunakan Java sebagai cara tercepat untuk memberikan contoh cepat dan agak kotor ini):

import java.awt.BasicStroke;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.HeadlessException;
import java.awt.Point;
import java.awt.RenderingHints;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.awt.event.MouseMotionListener;
import java.util.ArrayList;
import java.util.List;
import javax.swing.JFrame;
import javax.swing.SwingUtilities;

public class CircleGestureDemo extends JFrame implements MouseListener, MouseMotionListener {

    enum Type {
        RIGHT_DOWN,
        LEFT_DOWN,
        LEFT_UP,
        RIGHT_UP,
        UNDEFINED
    }

    private static final Type[] circleShape = {
        Type.RIGHT_DOWN,
        Type.LEFT_DOWN,
        Type.LEFT_UP,
        Type.RIGHT_UP};

    private boolean editing = false;
    private Point[] bounds;
    private Point last = new Point(0, 0);
    private List<Point> points = new ArrayList<>();

    public CircleGestureDemo() throws HeadlessException {
        super("Detect Circle");

        addMouseListener(this);
        addMouseMotionListener(this);
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

        setPreferredSize(new Dimension(800, 600));
        pack();
    }

    @Override
    public void paint(Graphics graphics) {
        Dimension d = getSize();
        Graphics2D g = (Graphics2D) graphics;

        super.paint(g);

        RenderingHints qualityHints = new RenderingHints(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
        qualityHints.put(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_QUALITY);
        g.setRenderingHints(qualityHints);

        g.setColor(Color.RED);
        if (cD == 0) {
            Point b = null;
            for (Point e : points) {
                if (null != b) {
                    g.drawLine(b.x, b.y, e.x, e.y);
                }
                b = e;
            }
        }else if (cD > 0){
            g.setColor(Color.BLUE);
            g.setStroke(new BasicStroke(3));
            g.drawOval(cX, cY, cD, cD);
        }else{
            g.drawString("Uknown",30,50);
        }
    }


    private Type getType(int dx, int dy) {
        Type result = Type.UNDEFINED;

        if (dx > 0 && dy < 0) {
            result = Type.RIGHT_DOWN;
        } else if (dx < 0 && dy < 0) {
            result = Type.LEFT_DOWN;
        } else if (dx < 0 && dy > 0) {
            result = Type.LEFT_UP;
        } else if (dx > 0 && dy > 0) {
            result = Type.RIGHT_UP;
        }

        return result;
    }

    private boolean isCircle(List<Point> points) {
        boolean result = false;
        Type[] shape = circleShape;
        Type[] detected = new Type[shape.length];
        bounds = new Point[shape.length];

        final int STEP = 5;

        int index = 0;        
        Point current = points.get(0);
        Type type = null;

        for (int i = STEP; i < points.size(); i += STEP) {
            Point next = points.get(i);
            int dx = next.x - current.x;
            int dy = -(next.y - current.y);

            if(dx == 0 || dy == 0) {
                continue;
            }

            Type newType = getType(dx, dy);
            if(type == null || type != newType) {
                if(newType != shape[index]) {
                    break;
                }
                bounds[index] = current;
                detected[index++] = newType;
            }
            type = newType;            
            current = next;

            if (index >= shape.length) {
                result = true;
                break;
            }
        }

        return result;
    }

    @Override
    public void mousePressed(MouseEvent e) {
        cD = 0;
        points.clear();
        editing = true;
    }

    private int cX;
    private int cY;
    private int cD;

    @Override
    public void mouseReleased(MouseEvent e) {
        editing = false;
        if(points.size() > 0) {
            if(isCircle(points)) {
                cX = bounds[0].x + Math.abs((bounds[2].x - bounds[0].x)/2);
                cY = bounds[0].y;
                cD = bounds[2].y - bounds[0].y;
                cX = cX - cD/2;

                System.out.println("circle");
            }else{
                cD = -1;
                System.out.println("unknown");
            }
            repaint();
        }
    }

    @Override
    public void mouseDragged(MouseEvent e) {
        Point newPoint = e.getPoint();
        if (editing && !last.equals(newPoint)) {
            points.add(newPoint);
            last = newPoint;
            repaint();
        }
    }

    @Override
    public void mouseMoved(MouseEvent e) {
    }

    @Override
    public void mouseEntered(MouseEvent e) {
    }

    @Override
    public void mouseExited(MouseEvent e) {
    }

    @Override
    public void mouseClicked(MouseEvent e) {
    }

    public static void main(String[] args) {
        SwingUtilities.invokeLater(new Runnable() {

            @Override
            public void run() {
                CircleGestureDemo t = new CircleGestureDemo();
                t.setVisible(true);
            }
        });
    }
}

Seharusnya tidak menjadi masalah untuk menerapkan perilaku serupa di iOS, karena Anda hanya perlu beberapa acara dan koordinat. Sesuatu seperti berikut ini (lihat contoh ):

- (void)touchesBegan:(NSSet *)touches withEvent:(UIEvent *)event {
    UITouch* touch = [[event allTouches] anyObject];
}

- (void)handleTouch:(UIEvent *)event {
    UITouch* touch = [[event allTouches] anyObject];
    CGPoint location = [touch locationInView:self];

}

- (void)touchesMoved:(NSSet *)touches withEvent:(UIEvent *)event {
    [self handleTouch: event];
}

- (void)touchesEnded:(NSSet *)touches withEvent:(UIEvent *)event {
    [self handleTouch: event];    
}

Ada beberapa perangkat tambahan yang mungkin.

Mulai kapan saja

Persyaratan saat ini adalah mulai menggambar lingkaran dari titik tengah atas karena penyederhanaan berikut:

        if(type == null || type != newType) {
            if(newType != shape[index]) {
                break;
            }
            bounds[index] = current;
            detected[index++] = newType;
        }

Mohon perhatikan nilai default dari indexyang digunakan. Pencarian sederhana melalui "bagian" bentuk yang tersedia akan menghapus batasan itu. Harap dicatat Anda harus menggunakan buffer bundar untuk mendeteksi bentuk penuh:

Searah jarum jam dan berlawanan arah jarum jam

Untuk mendukung kedua mode ini, Anda harus menggunakan buffer bundar dari perangkat tambahan sebelumnya dan mencari di kedua arah:

Gambarkan elips

Anda sudah memiliki semua yang Anda butuhkan di dalam boundsarray.

Cukup gunakan data itu:

cWidth = bounds[2].y - bounds[0].y;
cHeight = bounds[3].y - bounds[1].y;

Gerakan lain (opsional)

Terakhir, Anda hanya perlu menangani situasi dengan benar dx(atau dy) sama dengan nol untuk mendukung gerakan lain:

Memperbarui

PoC kecil ini mendapat perhatian yang cukup tinggi, jadi saya memperbarui sedikit kode untuk membuatnya bekerja dengan lancar dan memberikan beberapa petunjuk menggambar, menyorot poin pendukung, dll:

Ini kodenya:

import java.awt.BasicStroke;
import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.HeadlessException;
import java.awt.Point;
import java.awt.RenderingHints;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.awt.event.MouseMotionListener;
import java.util.ArrayList;
import java.util.List;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.SwingUtilities;

public class CircleGestureDemo extends JFrame {

    enum Type {

        RIGHT_DOWN,
        LEFT_DOWN,
        LEFT_UP,
        RIGHT_UP,
        UNDEFINED
    }

    private static final Type[] circleShape = {
        Type.RIGHT_DOWN,
        Type.LEFT_DOWN,
        Type.LEFT_UP,
        Type.RIGHT_UP};

    public CircleGestureDemo() throws HeadlessException {
        super("Circle gesture");
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        setLayout(new BorderLayout());
        add(BorderLayout.CENTER, new GesturePanel());
        setPreferredSize(new Dimension(800, 600));
        pack();
    }

    public static class GesturePanel extends JPanel implements MouseListener, MouseMotionListener {

        private boolean editing = false;
        private Point[] bounds;
        private Point last = new Point(0, 0);
        private final List<Point> points = new ArrayList<>();

        public GesturePanel() {
            super(true);
            addMouseListener(this);
            addMouseMotionListener(this);
        }

        @Override
        public void paint(Graphics graphics) {
            super.paint(graphics);

            Dimension d = getSize();
            Graphics2D g = (Graphics2D) graphics;

            RenderingHints qualityHints = new RenderingHints(RenderingHints.KEY_ANTIALIASING,
                    RenderingHints.VALUE_ANTIALIAS_ON);
            qualityHints.put(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_QUALITY);

            g.setRenderingHints(qualityHints);

            if (!points.isEmpty() && cD == 0) {
                isCircle(points, g);
                g.setColor(HINT_COLOR);
                if (bounds[2] != null) {
                    int r = (bounds[2].y - bounds[0].y) / 2;
                    g.setStroke(new BasicStroke(r / 3 + 1));
                    g.drawOval(bounds[0].x - r, bounds[0].y, 2 * r, 2 * r);
                } else if (bounds[1] != null) {
                    int r = bounds[1].x - bounds[0].x;
                    g.setStroke(new BasicStroke(r / 3 + 1));
                    g.drawOval(bounds[0].x - r, bounds[0].y, 2 * r, 2 * r);
                }
            }

            g.setStroke(new BasicStroke(2));
            g.setColor(Color.RED);

            if (cD == 0) {
                Point b = null;
                for (Point e : points) {
                    if (null != b) {
                        g.drawLine(b.x, b.y, e.x, e.y);
                    }
                    b = e;
                }

            } else if (cD > 0) {
                g.setColor(Color.BLUE);
                g.setStroke(new BasicStroke(3));
                g.drawOval(cX, cY, cD, cD);
            } else {
                g.drawString("Uknown", 30, 50);
            }
        }

        private Type getType(int dx, int dy) {
            Type result = Type.UNDEFINED;

            if (dx > 0 && dy < 0) {
                result = Type.RIGHT_DOWN;
            } else if (dx < 0 && dy < 0) {
                result = Type.LEFT_DOWN;
            } else if (dx < 0 && dy > 0) {
                result = Type.LEFT_UP;
            } else if (dx > 0 && dy > 0) {
                result = Type.RIGHT_UP;
            }

            return result;
        }

        private boolean isCircle(List<Point> points, Graphics2D g) {
            boolean result = false;
            Type[] shape = circleShape;
            bounds = new Point[shape.length];

            final int STEP = 5;
            int index = 0;
            int initial = 0;
            Point current = points.get(0);
            Type type = null;

            for (int i = STEP; i < points.size(); i += STEP) {
                final Point next = points.get(i);
                final int dx = next.x - current.x;
                final int dy = -(next.y - current.y);

                if (dx == 0 || dy == 0) {
                    continue;
                }

                final int marker = 8;
                if (null != g) {
                    g.setColor(Color.BLACK);
                    g.setStroke(new BasicStroke(2));
                    g.drawOval(current.x - marker/2, 
                               current.y - marker/2, 
                               marker, marker);
                }

                Type newType = getType(dx, dy);
                if (type == null || type != newType) {
                    if (newType != shape[index]) {
                        break;
                    }
                    bounds[index++] = current;
                }

                type = newType;
                current = next;
                initial = i;

                if (index >= shape.length) {
                    result = true;
                    break;
                }
            }
            return result;
        }

        @Override
        public void mousePressed(MouseEvent e) {
            cD = 0;
            points.clear();
            editing = true;
        }

        private int cX;
        private int cY;
        private int cD;

        @Override
        public void mouseReleased(MouseEvent e) {
            editing = false;
            if (points.size() > 0) {
                if (isCircle(points, null)) {
                    int r = Math.abs((bounds[2].y - bounds[0].y) / 2);
                    cX = bounds[0].x - r;
                    cY = bounds[0].y;
                    cD = 2 * r;
                } else {
                    cD = -1;
                }
                repaint();
            }
        }

        @Override
        public void mouseDragged(MouseEvent e) {
            Point newPoint = e.getPoint();
            if (editing && !last.equals(newPoint)) {
                points.add(newPoint);
                last = newPoint;
                repaint();
            }
        }

        @Override
        public void mouseMoved(MouseEvent e) {
        }

        @Override
        public void mouseEntered(MouseEvent e) {
        }

        @Override
        public void mouseExited(MouseEvent e) {
        }

        @Override
        public void mouseClicked(MouseEvent e) {
        }
    }

    public static void main(String[] args) {
        SwingUtilities.invokeLater(new Runnable() {

            @Override
            public void run() {
                CircleGestureDemo t = new CircleGestureDemo();
                t.setVisible(true);
            }
        });
    }

    final static Color HINT_COLOR = new Color(0x55888888, true);
}

Teknik Visi Komputer klasik untuk mendeteksi bentuk adalah Hough Transform. Salah satu hal yang menyenangkan tentang Hough Transform adalah sangat toleran terhadap data parsial, data tidak sempurna, dan kebisingan. Menggunakan Hough untuk lingkaran: http://en.wikipedia.org/wiki/Hough_transform#Circle_detection_process

Mengingat bahwa lingkaran Anda digambar tangan, saya pikir transformasi Hough mungkin cocok untuk Anda.

Inilah penjelasan "disederhanakan", saya minta maaf karena itu tidak benar-benar sesederhana itu. Sebagian besar dari proyek sekolah yang saya lakukan bertahun-tahun yang lalu.

The Hough Transform adalah skema pemungutan suara. Array bilangan bulat dua dimensi dialokasikan dan semua elemen diatur ke nol. Setiap elemen terkait dengan satu piksel dalam gambar yang dianalisis. Array ini disebut sebagai array akumulator karena setiap elemen akan mengumpulkan informasi, suara, yang menunjukkan kemungkinan bahwa suatu pixel mungkin berasal dari asal-usul lingkaran atau busur.

Detektor tepi operator gradien diterapkan pada gambar dan piksel tepi, atau edgels, direkam. Edgel adalah piksel yang memiliki intensitas atau warna berbeda sehubungan dengan tetangganya. Tingkat perbedaan disebut gradient magnitude. Untuk setiap edgel dengan besaran yang cukup, skema pemungutan suara diterapkan yang akan menambah elemen array akumulator. Elemen-elemen yang ditambahkan (dipilih) sesuai dengan kemungkinan asal usul lingkaran yang melewati edgel yang sedang dipertimbangkan. Hasil yang diinginkan adalah bahwa jika ada busur maka asal yang benar akan menerima lebih banyak suara daripada asal yang salah.

Perhatikan bahwa elemen array akumulator yang dikunjungi untuk pemungutan suara membentuk lingkaran di sekitar edgel yang sedang dipertimbangkan. Menghitung koordinat x, y untuk memilih sama dengan menghitung koordinat x, y dari lingkaran yang Anda gambar.

Pada gambar yang digambar dengan tangan Anda, Anda mungkin dapat menggunakan piksel yang diset (berwarna) secara langsung daripada menghitung edgels.

Sekarang dengan piksel yang terletak tidak sempurna Anda tidak perlu mendapatkan elemen array akumulator tunggal dengan jumlah suara terbanyak. Anda bisa mendapatkan koleksi elemen array tetangga dengan sekelompok suara, sebuah cluster. Pusat gravitasi dari kluster ini dapat menawarkan perkiraan yang baik untuk asal usulnya.

Perhatikan bahwa Anda mungkin harus menjalankan Hough Transform untuk nilai jari-jari R. yang berbeda yang menghasilkan kumpulan suara yang lebih padat adalah kecocokan "lebih baik".

Ada berbagai teknik yang digunakan untuk mengurangi suara untuk asal-usul palsu. Sebagai contoh satu keuntungan menggunakan edgels adalah bahwa mereka tidak hanya memiliki magnitudo tetapi mereka juga memiliki arah. Saat memberikan suara, kita hanya perlu memilih kemungkinan asal ke arah yang sesuai. Lokasi yang menerima suara akan membentuk busur daripada lingkaran lengkap.

Ini sebuah contoh. Kita mulai dengan lingkaran jari-jari satu dan array akumulator yang diinisialisasi. Karena setiap piksel dianggap sebagai asal potensial dipilih untuk. Asal sebenarnya menerima suara terbanyak yang dalam hal ini adalah empat.

.  empty pixel
X  drawn pixel
*  drawn pixel currently being considered

. . . . .   0 0 0 0 0
. . X . .   0 0 0 0 0
. X . X .   0 0 0 0 0
. . X . .   0 0 0 0 0
. . . . .   0 0 0 0 0

. . . . .   0 0 0 0 0
. . X . .   0 1 0 0 0
. * . X .   1 0 1 0 0
. . X . .   0 1 0 0 0
. . . . .   0 0 0 0 0

. . . . .   0 0 0 0 0
. . X . .   0 1 0 0 0
. X . X .   1 0 2 0 0
. . * . .   0 2 0 1 0
. . . . .   0 0 1 0 0

. . . . .   0 0 0 0 0
. . X . .   0 1 0 1 0
. X . * .   1 0 3 0 1
. . X . .   0 2 0 2 0
. . . . .   0 0 1 0 0

. . . . .   0 0 1 0 0
. . * . .   0 2 0 2 0
. X . X .   1 0 4 0 1
. . X . .   0 2 0 2 0
. . . . .   0 0 1 0 0

Ini cara lain. Menggunakan UIView touchesMulai, touchesMoved, touchEnded dan menambahkan poin ke array. Anda membagi array menjadi dua, dan menguji apakah setiap titik dalam satu array kira-kira memiliki diameter yang sama dari pasangannya di array lain seperti semua pasangan lainnya.

    NSMutableArray * pointStack;

    - (void)touchesBegan:(NSSet *)touches withEvent:(UIEvent *)event
    {
        // Detect touch anywhere
    UITouch *touch = [touches anyObject];


    pointStack = [[NSMutableArray alloc]init];

    CGPoint touchDownPoint = [touch locationInView:touch.view];


    [pointStack addObject:touchDownPoint];

    }


    /**
     * 
     */
    - (void)touchesMoved:(NSSet *)touches withEvent:(UIEvent *)event
    {

            UITouch* touch = [touches anyObject];
            CGPoint touchDownPoint = [touch locationInView:touch.view];

            [pointStack addObject:touchDownPoint];  

    }

    /**
     * So now you have an array of lots of points
     * All you have to do is find what should be the diameter
     * Then compare opposite points to see if the reach a similar diameter
     */
    - (void)touchesEnded:(NSSet *)touches withEvent:(UIEvent *)event
    {
            uint pointCount = [pointStack count];

    //assume the circle was drawn a constant rate and the half way point will serve to calculate or diameter
    CGPoint startPoint = [pointStack objectAtIndex:0];
    CGPoint halfWayPoint = [pointStack objectAtIndex:floor(pointCount/2)];

    float dx = startPoint.x - halfWayPoint.x;
    float dy = startPoint.y - halfWayPoint.y;


    float diameter = sqrt((dx*dx) + (dy*dy));

    bool isCircle = YES;// try to prove false!

    uint indexStep=10; // jump every 10 points, reduce to be more granular

    // okay now compare matches
    // e.g. compare indexes against their opposites and see if they have the same diameter
    //
      for (uint i=indexStep;i<floor(pointCount/2);i+=indexStep)
      {

      CGPoint testPointA = [pointStack objectAtIndex:i];
      CGPoint testPointB = [pointStack objectAtIndex:floor(pointCount/2)+i];

      dx = testPointA.x - testPointB.x;
      dy = testPointA.y - testPointB.y;


      float testDiameter = sqrt((dx*dx) + (dy*dy));

      if(testDiameter>=(diameter-10) && testDiameter<=(diameter+10)) // +/- 10 ( or whatever degree of variance you want )
      {
      //all good
      }
      else
      {
      isCircle=NO;
      }

    }//end for loop

    NSLog(@"iCircle=%i",isCircle);

}

Kedengarannya oke? :)

Saya bukan ahli pengenalan bentuk, tapi inilah cara saya mendekati masalah.

Pertama, saat menampilkan jalur pengguna sebagai bebas tangan, diam-diam mengumpulkan daftar titik (x, y) sampel bersamaan dengan waktu. Anda bisa mendapatkan kedua fakta dari acara seret, membungkusnya menjadi objek model sederhana, dan menumpuknya dalam array yang bisa berubah.

Anda mungkin ingin mengambil sampel dengan cukup sering — katakanlah, setiap 0,1 detik. Kemungkinan lain adalah mulai benar-benar sering, mungkin setiap 0,05 detik, dan perhatikan berapa lama pengguna menyeret; jika mereka menyeret lebih lama dari jumlah waktu tertentu, maka turunkan frekuensi sampel (dan jatuhkan sampel apa pun yang terlewatkan) menjadi sekitar 0,2 detik.

(Dan jangan mengambil nomor saya untuk Injil, karena saya baru saja mengeluarkannya dari topi saya. Bereksperimen dan temukan nilai yang lebih baik.)

Kedua, menganalisis sampel.

Anda ingin mendapatkan dua fakta. Pertama, pusat bentuk, yang (IIRC) seharusnya hanya rata-rata dari semua titik. Kedua, radius rata-rata setiap sampel dari pusat itu.

Jika, seperti yang ditebak @ user1118321, Anda ingin mendukung poligon, maka sisa analisisnya terdiri dari membuat keputusan itu: apakah pengguna ingin menggambar lingkaran atau poligon. Anda dapat melihat sampel sebagai poligon untuk memulai dengan menentukan itu.

Ada beberapa kriteria yang dapat Anda gunakan:

• Waktu: Jika pengguna melayang lebih lama di beberapa titik daripada yang lain (yang, jika sampel berada pada interval konstan, akan muncul sebagai sekelompok sampel berurutan berdekatan satu sama lain dalam ruang), itu mungkin sudut. Anda harus membuat ambang sudut Anda kecil sehingga pengguna dapat melakukan ini secara tidak sadar, daripada harus sengaja berhenti di setiap sudut.
• Sudut: Sebuah lingkaran akan memiliki sudut yang kira-kira sama dari satu sampel ke yang berikutnya sepanjang jalan. Poligon akan memiliki beberapa sudut yang bergabung dengan segmen garis lurus; sudut adalah sudutnya. Untuk poligon beraturan (lingkaran ke elips poligon tidak beraturan), sudut sudut harus kira-kira sama; poligon tidak beraturan akan memiliki sudut sudut yang berbeda.
• Interval: Pojok-pojok poligon beraturan akan memiliki jarak yang sama di dalam dimensi sudut, dan jari-jari akan konstan. Poligon yang tidak beraturan akan memiliki interval sudut yang tidak teratur dan / atau jari-jari yang tidak konstan.

Langkah ketiga dan terakhir adalah membuat bentuk, berpusat pada titik pusat yang telah ditentukan sebelumnya, dengan jari-jari yang ditentukan sebelumnya.

Tidak ada jaminan bahwa apa pun yang saya katakan di atas akan berfungsi atau menjadi efisien, tetapi saya harap itu setidaknya membuat Anda berada di jalur yang benar — dan tolong, jika ada orang yang tahu lebih banyak tentang pengenalan bentuk daripada saya (yang merupakan bilah yang sangat rendah) melihat ini, jangan ragu untuk mengirim komentar atau jawaban Anda sendiri.

Saya sudah cukup beruntung dengan pengenal $ 1 yang terlatih dengan baik ( http://depts.washington.edu/aimgroup/proj/dollar/ ). Saya menggunakannya untuk lingkaran, garis, segitiga dan kotak.

Sudah lama sekali, sebelum UIGestureRecognizer, tapi saya pikir itu harus mudah untuk membuat subclass UIGestureRecognizer yang tepat.

Setelah Anda menentukan pengguna selesai menggambar bentuk di mana mereka mulai, Anda dapat mengambil sampel dari koordinat yang mereka gambar dan coba paskan mereka ke lingkaran.

Ada solusi MATLAB untuk masalah ini di sini: http://www.mathworks.com.au/matlabcentral/fileexchange/15060-fitcircle-m

Yang didasarkan pada makalah Least-Squares Fitting of Circles and Ellipses oleh Walter Gander, Gene H. Golub dan Rolf Strebel: http://www.emis.de/journals/BBMS/Bulletin/sup962/gander.pdf

Dr Ian Coope dari University of Canterbury, NZ menerbitkan sebuah makalah dengan abstrak:

Masalah menentukan lingkaran paling cocok untuk satu set poin di pesawat (atau generalisasi yang jelas ke dimensi-n) dengan mudah diformulasikan sebagai masalah total-kuadrat terkecil nonlinier yang dapat diselesaikan dengan menggunakan algoritma minimisasi Gauss-Newton. Pendekatan langsung ini terbukti tidak efisien dan sangat sensitif terhadap kehadiran pencilan. Formulasi alternatif memungkinkan masalah tersebut direduksi menjadi masalah linear kuadrat terkecil yang diselesaikan secara sepele. Pendekatan yang direkomendasikan terbukti memiliki keuntungan tambahan yaitu menjadi jauh kurang sensitif terhadap pencilan daripada pendekatan kuadrat terkecil nonlinier.

http://link.springer.com/article/10.1007%2FBF00939613

File MATLAB dapat menghitung masalah TLS nonlinear dan linear LLS.

Berikut cara yang cukup sederhana menggunakan:

- (UIView *)hitTest:(CGPoint)point withEvent:(UIEvent *)event

dengan asumsi kisi matriks ini:

 A B C D E F G H
1      X X
2    X     X 
3  X         X
4  X         X
5    X     X
6      X X
7
8

Tempatkan beberapa UIViews di lokasi "X" dan uji mereka untuk menjadi hit (secara berurutan). Jika mereka semua terkena secara berurutan, saya pikir mungkin adil untuk membiarkan pengguna mengatakan "Bagus, Anda menggambar lingkaran"

Kedengarannya oke? (dan sederhana)