c# - senos - Encuentra el tamaño del pecho usando Kinect v2

inflamacion de un seno en niñas

Question

Necesito averiguar la medida frontal del cofre para cualquier persona que use Kinect mientras mira hacia la cámara. Mi solución actual es:

1. Cuando llega un MultiFrameSource, obtenga el color (para mostrar el cuerpo en la interfaz de usuario) el cuerpo (para obtener las uniones) y los marcos bodyIndex.

2. copie el BodyIndexFrame en un byte [] _bodyData usando:

   bodyIndexFrame.CopyFrameDataToArray(_bodyData);

3. Obtengo los objetos Conjuntos para: spineShoulder y spineMid. He asumido que el cofre siempre estará entre esos puntos .

4. Convierto ambas uniones a CameraSpacePoint (x, y, z) y de CameraSpacePoint a DepthSpacePoint (x, y) usando

   _sensor.CoordinateMapper.MapCameraPointToDepthSpace(jointPosition);

Todavía mantengo una referencia al valor z de spineShoulder.

5. Segundo supuesto => Comenzando desde spineShoulderY hasta spineMidY Intento encontrar el punto más ancho que se encuentra en el área del jugador. para hacerlo, intentaré encontrar el segmento más largo entre spineShoulderX y la primera región izquierda encontrada que no pertenece al jugador y el segmento más largo entre spineShoulderX y la primera región del lado derecho encontrada que no pertenece al jugador. Los dos segmentos x encontrados deben estar en la misma coordenada y.

   /***************
    * Returns the distance between 2 points
    */
   private static int getDistanceToMid(int pointX, int midX)
   {
       if (midX > pointX)
       {
           return (midX - pointX);
       }
       else if (pointX > midX)
       {
           return (pointX - midX);
       }
       else
       {
           return 0;
       }
   }
   
   
   /*********
    * Loops through the bodyData array 
    * It will look for the longest x distance from midX to the last left x value 
    * which still belongs to a player in the y coordinate
    */
   private static int findFarLeftX(byte[] bodyData,int depthWidth, int midX, int y)
   {
       int farLeftX = -1;
       for (int x = midX; x >= 0; --x)
       {
           int depthIndex = (y * depthWidth) + x;
   
           if (depthIndex > 0 && depthIndex < bodyData.Length)
           {
               byte player = bodyData[depthIndex];
   
               if (player != 0xff){
                   if (farLeftX == -1 || farLeftX > x)
                   {
                       farLeftX = x;
                   }
               } else{
                   return farLeftX;
               }
           }
       }
       return farLeftX;
   }
   
   /*********
    * Loops through the bodyData array 
    * It will look for the longest x distance from midX to the last right x value 
    * which still belongs to a player in the y coordinate
    */
   private static int findFarRightX(byte[] bodyData, int depthWidth, int midX, int y)
   {
       int farRightX = -1;
       for (int x = midX; x < depthWidth; ++x)
       {
           int depthIndex = (y * depthWidth) + x;
   
           if (depthIndex > 0 && depthIndex < bodyData.Length)
           {
               byte player = bodyData[depthIndex];
   
               if (player != 0xff)
               {
                   if (farRightX == -1 || farRightX < x)
                   {
                       farRightX = x;
                   } else{
                       return farRightX;
                   }
               }
           }
       }
       return farRightX;
   }
   
   
   private static BodyMember findElement(byte[] bodyData, int   depthHeight, int depthWidth, int startX, int startY, int endY)
   {
       BodyMember member = new BodyMember(-1, -1, -1, -1);
       int totalMaxSum = 0;
       int farLeftX = -1;
       int farRightX = -1;
       int selectedY = -1;
       for (int y = startY; y < depthHeight && y <= endY; ++y)
       {
   
           int leftX = findFarLeftX(bodyData, depthWidth, startX, y);
           int rightX = findFarRightX(bodyData, depthWidth, startX, y);
           if (leftX > -1 && rightX > -1)
           {
               int leftToMid = getDistanceToMid(leftX, startX);
               int rightToMid = getDistanceToMid(rightX, startX);
               int sum = leftToMid + rightToMid;
               if (sum > totalMaxSum)
               {
                   totalMaxSum = sum;
                   farLeftX = leftX;
                   farRightX = rightX;
                   selectedY = y;
               }
           }
       }
   
       member.setFarLeftX(farLeftX);
       member.setFarLeftY(selectedY);
       member.setFarRightX(farRightX);
       member.setFarRightY(selectedY);
       return member;
   
   }

6. findElement devolverá un objeto BodyMember que contiene farLeftX, farRightX, farLeftY y farRightY.

7. Creo 2 objetos DepthSpacePoint: DepthSpacePoint chestX1 = new DepthSpacePoint (); chestX1.X = bodyMemberObj.getFarLeftX (); chestX1.Y = bodyMemberObj.getFarLeftY ();

   DepthSpacePoint chestX2 = new DepthSpacePoint();
   chestX2.X = bodyMemberObj.getFarRightX();
   chestX2.Y = bodyMemberObj.getFarRightY();

8. Para obtener coordenadas del mundo real en metros, estos puntos se deben convertir en un objeto CameraSpacePoint. Para hacerlo, utilizaré el valor z de la unión al que mantuve una referencia en el punto 4.

   CameraSpacePoint chestLeft = _sensor.CoordinateMapper.MapDepthPointToCameraSpace(chestX1,spineShoulderZ);
   CameraSpacePoint chestRight = _sensor.CoordinateMapper.MapDepthPointToCameraSpace(chestX1,spineShoulderZ);

9. Ahora, si mi código y mis suposiciones son correctas , debería poder obtener la distancia correcta en metros para el cofre delantero.

   double chestLength = (chestLeft.X > chestRight.X) ? chestLeft - chestRight : chestRight - chestLeft;

Sin embargo, esto no parece estar devolviendo los valores correctos. He estado buscando una solución para esto durante semanas pero parece que estoy atascado.

Answer 1

¿Estás utilizando kinect One? Las mediciones en los kinects antiguos probablemente no son lo suficientemente precisas para satisfacer sus necesidades.

Sin embargo, desde mi punto de vista, también valdría la pena extraer el objeto en movimiento dentro de los marcos (si solo hay una persona frente al Kinect, recibirá el contorno de esta persona, pero para asegurarse de que pueda comparar su posición). con el esqueleto de Kinect).

Puede decirle a la persona que levante la mano durante un corto período de tiempo. Luego de usar la distancia de Kinect para el esqueleto de las personas y en función del tamaño del contorno y la distancia determinada, calcule la medición final del tórax justo debajo de los hombros (posición tomada del esqueleto). Tampoco estoy totalmente consciente de la precisión con la que Kinect maneja a las personas "más grandes".

Aquí se describe uno de los métodos: http://onlinelibrary.wiley.com/doi/10.1002/scj.10237/abstract También puede buscar en Google muchos otros artículos con un tema determinado (de forma gratuita).

¿Qué piensa usted acerca de esta idea? Aclamaciones

Answer 2

He trabajado con Kinect V2 y puedo decir que solo los datos de esqueleto pueden ser insuficientes para obtener resultados confiables. Incluso la ropa tiene un impacto en la forma en que Kinect interpreta las partes del cuerpo, por lo que tendrá que combinar los resultados de otros datos de sensores.

Además, le sugiero que sea creativo sobre cómo aborda esto; por ejemplo, podría investigar algunas posibles correlaciones anatómicas sobre el cuerpo humano, la altura más probable es un indicador proxy, tal vez la edad desde el reconocimiento de la cara y la altura es otra sugerencia, etc.