Example #1
0
        int IComparer.Compare(Object x, Object y)
        {
            DetectedMarker objetoA = (DetectedMarker)x;
            DetectedMarker objetoB = (DetectedMarker)y;

            return(objetoB.point3D.x.CompareTo(objetoA.point3D.x));
        }
        //Método executado a cada frame de vídeo
        public void OnBuffer(CaptureDevice i_sender, double i_sample_time, IntPtr i_buffer, int i_buffer_len)
        {
            try
            {
                i++;
                int                w             = i_sender.video_width;
                int                h             = i_sender.video_height;
                int                s             = w * (i_sender.video_bit_count / 8);
                Matrix             trans_matrix  = new Matrix();
                NyARTransMatResult nyar_transmat = this.__OnBuffer_nyar_transmat;

                Bitmap b = new Bitmap(w, h, s, PixelFormat.Format32bppRgb, i_buffer);

                // If the image is upsidedown
                b.RotateFlip(RotateFlipType.RotateNoneFlipY);
                this.pbxNyAR.Image = b;

                //Calculation of the AR - Seta o frame do vídeo no objeto Raster
                Core.raster.setBuffer(i_buffer, i_sender.video_vertical_flip);

                //Instância dos objetos de detecção
                detectedMarkersListLetters = new ArrayList();
                detectedMarkersListImages  = new ArrayList();
                NyARTransMatResult transMatrix;
                NyARDoublePoint3d  point3D;



                //Aqui vem a lógica do Bingo
                //1 - Detectar o marcador da cartela
                //2 - Verificar a relação de letras sorteadas e a palavra da cartela
                //3 - Se a palavra tiver todas as letras sorteadas, plotar o desenho específico
                //  - Senão, informa de algum jeito o total das letras, e qual falta, sei lá.

                //Verficar a palavra relacionada à cartela
                string originalWord = string.Empty;

                //Adiciona as letras sorteadas no ArrayList para comparação
                raffledLetters = new ArrayList();
                foreach (char item in gmNyAR.RaffleLetters)
                {
                    raffledLetters.Add(item);
                }



                if (intRefresh == 0)
                {
                    //Detecção das LETRAS
                    int totalMarkersLetter           = this.markerDetectorLetters.detectMarkerLite(Core.raster, 100);
                    int markerLetterId               = 0;
                    NyARTransMatResult transMatKanji = new NyARTransMatResult();

                    //Caso encontrar marcadores
                    if (totalMarkersLetter > 0)
                    {
                        for (int counter = 0; counter < totalMarkersLetter; counter++)
                        {
                            markerLetterId = this.markerDetectorLetters.getARCodeIndex(counter);

                            if (this.markerDetectorLetters.getConfidence(counter) > 0.60)
                            {
                                if (markerLetterId == 0)
                                {
                                    this.markerDetectorLetters.getTransmationMatrix(markerLetterId, transMatKanji);
                                }
                                else
                                {
                                    //Recupera o ângulo XYZ do marcador e salva na lista.
                                    transMatrix = new NyARTransMatResult();
                                    point3D     = new NyARDoublePoint3d();
                                    this.markerDetectorLetters.getTransmationMatrix(counter, transMatrix);
                                    transMatrix.getZXYAngle(point3D);

                                    detectedMarker          = new DetectedMarker();
                                    detectedMarker.markerID = markerLetterId;
                                    detectedMarker.point3D  = point3D;
                                    detectedMarkersListLetters.Add(detectedMarker);
                                }
                            }
                        }
                    }

                    //Detecção dos marcadores específicos
                    int totalMarkerImages = this.markerDetectorImages.detectMarkerLite(Core.raster, 100);
                    int markerImageId     = 0;

                    if (totalMarkerImages > 0)
                    {
                        for (int counter = 0; counter < totalMarkerImages; counter++)
                        {
                            markerImageId = this.markerDetectorImages.getARCodeIndex(counter);

                            if (this.markerDetectorImages.getConfidence(counter) > 0.50)
                            {
                                //Recupera o ângulo XYZ do marcador e salva na lista.
                                transMatrix = new NyARTransMatResult();
                                point3D     = new NyARDoublePoint3d();
                                this.markerDetectorImages.getTransmationMatrix(counter, transMatrix);
                                transMatrix.getZXYAngle(point3D);

                                detectedMarker          = new DetectedMarker();
                                detectedMarker.markerID = markerImageId;
                                detectedMarker.point3D  = point3D;
                                detectedMarkersListImages.Add(detectedMarker);
                            }
                        }
                    }



                    if ((detectedMarkersListLetters.Count + detectedMarkersListImages.Count) > 0)
                    {
                        if ((detectedMarkersListLetters.Count + detectedMarkersListImages.Count) > 1)
                        {
                            lbNyAR.Text = "Há letras que não foram preenchidas na cartela";
                            //Fazer algo para avisar que nem todas as letras foram preenchidas.
                        }
                        else
                        {
                            if (detectedMarkersListImages.Count > 0)
                            {
                                //switch das palavras correspondentes ao marcador encontrado.
                                switch (markerImageId)
                                {
                                case 0: originalWord = "BOLA";
                                    break;

                                case 1: originalWord = "ESPADA";
                                    break;

                                case 2: originalWord = "CARRO";
                                    break;

                                case 3: originalWord = "BRIGADEIRO";
                                    break;

                                case 4: originalWord = "GARFO";
                                    break;

                                case 5: originalWord = "CANETA";
                                    break;

                                case 6: originalWord = "PEIXE";
                                    break;
                                }

                                int total = checkTotalLetters(raffledLetters, originalWord);

                                //Se todas as letras da palavra tiverem sido sorteadas, plota a imagem
                                if (total == originalWord.Length)
                                {
                                    lbNyAR.Text = "BINGO! Palavra: " + originalWord;
                                    intRefresh++;
                                    intDetected = markerImageId;
                                }
                                else
                                {
                                    lbNyAR.Text = "Algumas letras ainda não foram sorteadas";
                                    //Verificar o que vai fazer... pode ser uma mensagem na tela.
                                }
                            }
                        }
                    }
                }
                else
                {
                    bool detected;
                    switch (intDetected)
                    {
                    case 0: detected = this.ballMarkerDetector.detectMarkerLite(Core.raster);
                        if (detected)
                        {
                            NyARTransMatResult result = new NyARTransMatResult();
                            if (this.ballMarkerDetector.getConfidence() > 0.50)
                            {
                                this.ballMarkerDetector.getTransmationMatrix(result);
                                //DrawWord("bola", result);
                            }
                        }
                        break;

                    case 1: detected = this.swordMarkerDetector.detectMarkerLite(Core.raster);
                        if (detected)
                        {
                            NyARTransMatResult result = new NyARTransMatResult();
                            if (this.swordMarkerDetector.getConfidence() > 0.50)
                            {
                                this.swordMarkerDetector.getTransmationMatrix(result);
                                //DrawWord("espada", result);
                            }
                        }
                        break;

                    case 3: detected = this.carMarkerDetector.detectMarkerLite(Core.raster);
                        if (detected)
                        {
                            NyARTransMatResult result = new NyARTransMatResult();
                            if (this.carMarkerDetector.getConfidence() > 0.50)
                            {
                                this.carMarkerDetector.getTransmationMatrix(result);
                                //DrawWord("carro", result);
                            }
                        }
                        break;

                    case 4: detected = this.forkMarkerDetector.detectMarkerLite(Core.raster);
                        if (detected)
                        {
                            NyARTransMatResult result = new NyARTransMatResult();
                            if (this.forkMarkerDetector.getConfidence() > 0.50)
                            {
                                this.forkMarkerDetector.getTransmationMatrix(result);
                                DrawWord("garfo", result);
                            }
                        }
                        break;

                    case 5: detected = this.penMarkerDetector.detectMarkerLite(Core.raster);
                        if (detected)
                        {
                            NyARTransMatResult result = new NyARTransMatResult();
                            if (this.penMarkerDetector.getConfidence() > 0.50)
                            {
                                this.penMarkerDetector.getTransmationMatrix(result);
                                //DrawWord("caneta", result);
                            }
                        }
                        break;

                    case 6: detected = this.fishMarkerDetector.detectMarkerLite(Core.raster);
                        if (detected)
                        {
                            NyARTransMatResult result = new NyARTransMatResult();
                            if (this.fishMarkerDetector.getConfidence() > 0.50)
                            {
                                this.fishMarkerDetector.getTransmationMatrix(result);
                                DrawWord("peixe", result);
                            }
                        }
                        break;
                    }


                    //Refresh do detector
                    intRefresh++;
                    if (intRefresh > 20)
                    {
                        intRefresh  = 0;
                        intDetected = -1;
                    }
                }
            }
            catch (Exception e)
            {
                MessageBox.Show("Ocorreu um erro na verficação dos marcadores. Favor, reinicie a aplicação. Se o erro persistir, contate os desenvolvedores.", "Erro!");
                Environment.Exit(0);
            }
        }
        //Método executado a cada frame de vídeo
        public void OnBuffer(CaptureDevice i_sender, double i_sample_time, IntPtr i_buffer, int i_buffer_len)
        {
            try
            {
                i++;
                int                w             = i_sender.video_width;
                int                h             = i_sender.video_height;
                int                s             = w * (i_sender.video_bit_count / 8);
                Matrix             trans_matrix  = new Matrix();
                NyARTransMatResult nyar_transmat = this.__OnBuffer_nyar_transmat;

                Bitmap b = new Bitmap(w, h, s, PixelFormat.Format32bppRgb, i_buffer);

                // If the image is upsidedown
                b.RotateFlip(RotateFlipType.RotateNoneFlipY);
                this.pbxNyAR.Image = b;

                //Calculation of the AR - Seta o frame do vídeo no objeto Raster
                Core.raster.setBuffer(i_buffer, i_sender.video_vertical_flip);

                //Instância dos objetos de detecção
                detectedMarkersList = new ArrayList();
                NyARTransMatResult transMatrix;
                NyARDoublePoint3d  point3D;


                if (this.blnKanji == false)   //Controle Kanji. FALSE: Palavra não formada // TRUE: Palavra formada, pronto para plotar
                {
                    //Detecção
                    int    totalMarkers   = this.markerDetector.detectMarkerLite(Core.raster, 100);
                    int    markerId       = 0;
                    string palavraFormada = null;

                    NyARTransMatResult transMatKanji = new NyARTransMatResult();

                    //Caso encontrar marcadores
                    if (totalMarkers > 0)
                    {
                        for (int counter = 0; counter < totalMarkers; counter++)
                        {
                            markerId = this.markerDetector.getARCodeIndex(counter);

                            if (this.markerDetector.getConfidence(counter) > 0.60)
                            {
                                if (markerId == 0)
                                {
                                    this.markerDetector.getTransmationMatrix(markerId, transMatKanji);
                                }
                                else
                                {
                                    //Recupera o ângulo XYZ do marcador e salva na lista.
                                    transMatrix = new NyARTransMatResult();
                                    point3D     = new NyARDoublePoint3d();
                                    this.markerDetector.getTransmationMatrix(counter, transMatrix);
                                    transMatrix.getZXYAngle(point3D);


                                    detectedMarker          = new DetectedMarker();
                                    detectedMarker.markerID = markerId;
                                    detectedMarker.point3D  = point3D;
                                    detectedMarkersList.Add(detectedMarker);
                                }
                            }
                        }
                    }


                    //Realiza os cálculos da RA caso encontrar algum marcador válido
                    if (detectedMarkersList.Count > 0)
                    {
                        //Ordena a lista de acordo com a posição
                        detectedMarkersList.Sort(new OrdenacaoPorX());

                        //Monta a palavra de acordo com os marcadores detectados
                        foreach (DetectedMarker item in detectedMarkersList)
                        {
                            palavraFormada += this.arrayLetters[item.markerID - 1];
                        }

                        if (detectedMarkersList.Count == 3)
                        {
                            totalMarkers = totalMarkers + 0;
                        }



                        //Teste - Verifica o número de letras correspondentes
                        string originalWord = gmNyAR.SelectedObject;
                        int    total        = verificaTotalPalavraFormada(detectedMarkersList, originalWord);
                        if (total == originalWord.Length)
                        {
                            this.blnKanji     = true;
                            this.kanjiCounter = 0; //Refresh do contador
                            lbNyAR.Text       = "Palavra correta!";
                        }
                        else
                        {
                            if (intRefresh == 0)
                            {
                                if (total == 1)
                                {
                                    lbNyAR.Text = "Você acertou " + total + " letra! ";
                                }
                                else
                                {
                                    lbNyAR.Text = "Você acertou " + total + " letras! ";
                                }
                            }
                        }

                        // Realiza a gravação da pontuação
                        int points = (total / originalWord.Length) * 100;

                        if (points > int.Parse(gmNyAR.Points))
                        {
                            gmNyAR.Points = points.ToString();
                        }

                        //Refresh da label que indica a quantidade de letras corretas.
                        intRefresh++;
                        if (intRefresh > 20)
                        {
                            intRefresh = 0;
                        }
                    }
                }
                else
                {
                    //Desenho do objeto 3D no marcador Kanji.
                    bool kanji = this.kanjiDetector.detectMarkerLite(Core.raster);
                    if (kanji)
                    {
                        NyARTransMatResult result = new NyARTransMatResult();
                        if (this.kanjiDetector.getConfidence() > 0.50)
                        {
                            this.kanjiDetector.getTransmationMatrix(result);
                            DrawWord(gmNyAR.SelectedObject, result);
                        }
                    }
                    this.kanjiCounter++;
                    if (this.kanjiCounter > 50)
                    {
                        this.blnKanji = false;
                    }
                }
            }
            catch (Exception e)
            {
                MessageBox.Show("Ocorreu um erro na verficação dos marcadores. Favor, reinicie a aplicação. Se o erro persistir, contate os desenvolvedores.", "Erro!");
                Environment.Exit(0);
            }
        }