/// <summary>
            /// Constructs a constraint requiring the component to be a composed of a number of
            /// discrete flat surfaces of the count specified
            /// </summary>
            /// <param name="count">Number of discrete surfaces</param>
            /// <returns>Constructed component constraint</returns>
            public static ShapeComponentConstraint Create_SurfaceCount_Is(int count)
            {
                ShapeComponentConstraint constraint = new ShapeComponentConstraint();

                constraint.Type        = ShapeComponentConstraintType.SurfaceCount_Is;
                constraint.Param_Int_0 = count;
                return(constraint);
            }
            /// <summary>
            /// Constructs a constraint requiring the circle shaped component to have
            /// a specific radius
            /// </summary>
            /// <param name="radius">Required radius in meters</param>
            /// <returns>Constructed component constraint</returns>
            public static ShapeComponentConstraint Create_CircleRadius_Is(float radius)
            {
                ShapeComponentConstraint constraint = new ShapeComponentConstraint();

                constraint.Type          = ShapeComponentConstraintType.CircleRadius_Is;
                constraint.Param_Float_0 = radius;
                return(constraint);
            }
            /// <summary>
            /// Constructs a constraint requiring a maximum length.
            /// Length is the longer of the two bounding edges.
            /// </summary>
            /// <param name="maxLength">Maximum surface length</param>
            /// <returns>Constructed component constraint</returns>
            public static ShapeComponentConstraint Create_RectangleLength_Max(float maxLength)
            {
                ShapeComponentConstraint constraint = new ShapeComponentConstraint();

                constraint.Type          = ShapeComponentConstraintType.RectangleLength_Max;
                constraint.Param_Float_0 = maxLength;
                return(constraint);
            }
            /// <summary>
            /// Constructs a constraint requiring the component to contain a specific surface area
            /// </summary>
            /// <param name="area">Required surface area</param>
            /// <returns>Constructed component constraint</returns>
            public static ShapeComponentConstraint Create_SurfaceArea_Is(float area)
            {
                ShapeComponentConstraint constraint = new ShapeComponentConstraint();

                constraint.Type          = ShapeComponentConstraintType.SurfaceArea_Is;
                constraint.Param_Float_0 = area;
                return(constraint);
            }
            /// <summary>
            /// Constructs a constraint requiring a specific surface width.
            /// Width is the shorter of the two bounding edges.
            /// </summary>
            /// <param name="width">Required surface width</param>
            /// <returns>Constructed component constraint</returns>
            public static ShapeComponentConstraint Create_RectangleWidth_Is(float width)
            {
                ShapeComponentConstraint constraint = new ShapeComponentConstraint();

                constraint.Type          = ShapeComponentConstraintType.RectangleWidth_Is;
                constraint.Param_Float_0 = width;
                return(constraint);
            }
            /// <summary>
            /// Constructs a constraint requiring the component to not be a part of a specified shape
            /// </summary>
            /// <returns>Constructed component constraint</returns>
            public static ShapeComponentConstraint Create_SurfaceNotPartOfShape(string shapeName)
            {
                ShapeComponentConstraint constraint = new ShapeComponentConstraint();

                constraint.Type        = ShapeComponentConstraintType.SurfaceNotPartOfShape;
                constraint.Param_Str_0 = SpatialUnderstanding.Instance.UnderstandingDLL.PinString(shapeName);
                return(constraint);
            }
            /// <summary>
            /// Constructs a constraint requiring the component to be shaped like a circle
            ///
            /// The squares similarity is the percent of the surface that matches the
            /// containing circular component shape
            /// </summary>
            /// <param name="similarityMin">Minimum similarity to a circle</param>
            /// <returns>Constructed component constraint</returns>
            public static ShapeComponentConstraint Create_IsCircle(float similarityMin = 0.5f)
            {
                ShapeComponentConstraint constraint = new ShapeComponentConstraint();

                constraint.Type          = ShapeComponentConstraintType.IsCircle;
                constraint.Param_Float_0 = similarityMin;
                return(constraint);
            }
            /// <summary>
            /// Constructs a constraint requiring the component to be a specific height above the floor
            /// </summary>
            /// <param name="height">Required height above the floor</param>
            /// <returns>Constructed component constraint</returns>
            public static ShapeComponentConstraint Create_SurfaceHeight_Is(float height)
            {
                ShapeComponentConstraint constraint = new ShapeComponentConstraint();

                constraint.Type          = ShapeComponentConstraintType.SurfaceHeight_Is;
                constraint.Param_Float_0 = height;
                return(constraint);
            }
            /// <summary>
            /// Constructs a constraint requiring the component to have a specific surface area
            /// </summary>
            /// <param name="size">Required size in meters squared</param>
            /// <returns>Constructed component constraint</returns>
            public static ShapeComponentConstraint Create_SquareSize_Is(float size)
            {
                ShapeComponentConstraint constraint = new ShapeComponentConstraint();

                constraint.Type          = ShapeComponentConstraintType.SquareSize_Is;
                constraint.Param_Float_0 = size;
                return(constraint);
            }
            /// <summary>
            /// Constructs a constraint requiring the component to be within a height range above the floor
            /// </summary>
            /// <param name="minHeight">Minimum height above the floor</param>
            /// <param name="maxHeight">Maximum height above the floor</param>
            /// <returns>Constructed component constraint</returns>
            public static ShapeComponentConstraint Create_SurfaceHeight_Between(float minHeight, float maxHeight)
            {
                ShapeComponentConstraint constraint = new ShapeComponentConstraint();

                constraint.Type          = ShapeComponentConstraintType.SurfaceHeight_Between;
                constraint.Param_Float_0 = minHeight;
                constraint.Param_Float_1 = maxHeight;
                return(constraint);
            }
            /// <summary>
            /// Constructs a constraint requiring the circle shaped component to have
            /// a radius between the given range
            /// </summary>
            /// <param name="minRadius">Minimum radius in meters</param>
            /// <param name="maxRadius">Maximum radius in meters</param>
            /// <returns>Constructed component constraint</returns>
            public static ShapeComponentConstraint Create_CircleRadius_Between(float minRadius, float maxRadius)
            {
                ShapeComponentConstraint constraint = new ShapeComponentConstraint();

                constraint.Type          = ShapeComponentConstraintType.CircleRadius_Between;
                constraint.Param_Float_0 = minRadius;
                constraint.Param_Float_1 = maxRadius;
                return(constraint);
            }
            /// <summary>
            /// Constructs a constraint requiring the component to be a composed of a number of
            /// discrete flat surfaces between a specified range
            /// </summary>
            /// <param name="minCount">Minimum number of discrete surfaces</param>
            /// <param name="maxCount">Maximum number of discrete surfaces</param>
            /// <returns>Constructed component constraint</returns>
            public static ShapeComponentConstraint Create_SurfaceCount_Between(int minCount, int maxCount)
            {
                ShapeComponentConstraint constraint = new ShapeComponentConstraint();

                constraint.Type        = ShapeComponentConstraintType.SurfaceCount_Between;
                constraint.Param_Int_0 = minCount;
                constraint.Param_Int_1 = maxCount;
                return(constraint);
            }
            /// <summary>
            /// Constructs a constraint requiring a minimum length and width of the surface rectangle.
            /// Length is the longer of the two bounding edges and width the shorter edge.
            /// </summary>
            /// <param name="minLength">Minimum length</param>
            /// <param name="minWidth">Minimum width</param>
            /// <returns>Constructed component constraint</returns>
            public static ShapeComponentConstraint Create_RectangleSize_Min(float minLength, float minWidth)
            {
                ShapeComponentConstraint constraint = new ShapeComponentConstraint();

                constraint.Type          = ShapeComponentConstraintType.RectangleSize_Min;
                constraint.Param_Float_0 = minLength;
                constraint.Param_Float_1 = minWidth;
                return(constraint);
            }
            /// <summary>
            /// Constructs a constraint requiring the component to have a surface area
            /// between the given range
            /// </summary>
            /// <param name="minSize">Minimum size in meters squared</param>
            /// <param name="maxSize">Maximum size in meters squared</param>
            /// <returns>Constructed component constraint</returns>
            public static ShapeComponentConstraint Create_SquareSize_Between(float minSize, float maxSize)
            {
                ShapeComponentConstraint constraint = new ShapeComponentConstraint();

                constraint.Type          = ShapeComponentConstraintType.SquareSize_Between;
                constraint.Param_Float_0 = minSize;
                constraint.Param_Float_1 = maxSize;
                return(constraint);
            }
            /// <summary>
            /// Constructs a constraint requiring the surface width to be between the given range.
            /// Width is the shorter of the two bounding edges.
            /// </summary>
            /// <param name="minWidth">Minimum surface width</param>
            /// <param name="maxWidth">Maximum surface width</param>
            /// <returns>Constructed component constraint</returns>
            public static ShapeComponentConstraint Create_RectangleWidth_Between(float minWidth, float maxWidth)
            {
                ShapeComponentConstraint constraint = new ShapeComponentConstraint();

                constraint.Type          = ShapeComponentConstraintType.RectangleWidth_Between;
                constraint.Param_Float_0 = minWidth;
                constraint.Param_Float_1 = maxWidth;
                return(constraint);
            }
            /// <summary>
            /// Constructs a constraint requiring the component to contain a surface area
            /// between the range specified
            /// </summary>
            /// <param name="minArea">Minimum surface area</param>
            /// <param name="maxArea">Maximum surface area</param>
            /// <returns>Constructed component constraint</returns>
            public static ShapeComponentConstraint Create_SurfaceArea_Between(float minArea, float maxArea)
            {
                ShapeComponentConstraint constraint = new ShapeComponentConstraint();

                constraint.Type          = ShapeComponentConstraintType.SurfaceArea_Between;
                constraint.Param_Float_0 = minArea;
                constraint.Param_Float_1 = maxArea;
                return(constraint);
            }
            /// <summary>
            /// Constructs a constraint requiring the component to contain a maximum surface area
            /// </summary>
            /// <param name="maxArea">Maximum surface area</param>
            /// <returns>Constructed component constraint</returns>
            public static ShapeComponentConstraint Create_SurfaceArea_Max(float maxArea)
            {
                ShapeComponentConstraint constraint = new ShapeComponentConstraint
                {
                    Type          = ShapeComponentConstraintType.SurfaceArea_Max,
                    Param_Float_0 = maxArea
                };

                return(constraint);
            }
            /// <summary>
            /// Constructs a constraint requiring the component to be a maximum number of discrete flat surfaces
            /// </summary>
            /// <param name="maxCount">Maximum number of discrete surfaces</param>
            /// <returns>Constructed component constraint</returns>
            public static ShapeComponentConstraint Create_SurfaceCount_Max(int maxCount)
            {
                ShapeComponentConstraint constraint = new ShapeComponentConstraint
                {
                    Type        = ShapeComponentConstraintType.SurfaceCount_Max,
                    Param_Int_0 = maxCount
                };

                return(constraint);
            }
            /// <summary>
            /// Constructs a constraint requiring a specific surface length.
            /// Length is the longer of the two bounding edges.
            /// </summary>
            /// <param name="length">Required surface length</param>
            /// <returns>Constructed component constraint</returns>
            public static ShapeComponentConstraint Create_RectangleLength_Is(float length)
            {
                ShapeComponentConstraint constraint = new ShapeComponentConstraint
                {
                    Type          = ShapeComponentConstraintType.RectangleLength_Is,
                    Param_Float_0 = length
                };

                return(constraint);
            }
            /// <summary>
            /// Constructs a constraint requiring a maximum width.
            /// Width is the shorter of the two bounding edges.
            /// </summary>
            /// <param name="maxWidth">Maximum surface width</param>
            /// <returns>Constructed component constraint</returns>
            public static ShapeComponentConstraint Create_RectangleWidth_Max(float maxWidth)
            {
                ShapeComponentConstraint constraint = new ShapeComponentConstraint
                {
                    Type          = ShapeComponentConstraintType.RectangleWidth_Max,
                    Param_Float_0 = maxWidth
                };

                return(constraint);
            }
            /// <summary>
            /// Constructs a constraint requiring the component to be shaped like a square
            ///
            /// The squares similarity is the percent of the surface that matches the
            /// containing square component shape.
            /// </summary>
            /// <param name="similarityMin">Minimum similarity to a square</param>
            /// <returns>Constructed component constraint</returns>
            public static ShapeComponentConstraint Create_IsSquare(float similarityMin = 0.5f)
            {
                ShapeComponentConstraint constraint = new ShapeComponentConstraint
                {
                    Type          = ShapeComponentConstraintType.IsSquare,
                    Param_Float_0 = similarityMin
                };

                return(constraint);
            }
            /// <summary>
            /// Constructs a constraint requiring the component to have a maximum area
            /// </summary>
            /// <param name="maxSize">Maximum size in meters squared</param>
            /// <returns>Constructed component constraint</returns>
            public static ShapeComponentConstraint Create_SquareSize_Max(float maxSize)
            {
                ShapeComponentConstraint constraint = new ShapeComponentConstraint
                {
                    Type          = ShapeComponentConstraintType.SquareSize_Max,
                    Param_Float_0 = maxSize
                };

                return(constraint);
            }
            /// <summary>
            /// Constructs a constraint requiring the circle shaped component to have
            /// a maximum radius
            /// </summary>
            /// <param name="maxRadius">Maximum radius in meters</param>
            /// <returns>Constructed component constraint</returns>
            public static ShapeComponentConstraint Create_CircleRadius_Max(float maxRadius)
            {
                ShapeComponentConstraint constraint = new ShapeComponentConstraint
                {
                    Type          = ShapeComponentConstraintType.CircleRadius_Max,
                    Param_Float_0 = maxRadius
                };

                return(constraint);
            }
            /// <summary>
            /// Constructs a constraint requiring the component to be a minimum height above the floor
            /// </summary>
            /// <param name="minHeight">Minimum height above the floor</param>
            /// <returns>Constructed component constraint</returns>
            public static ShapeComponentConstraint Create_SurfaceHeight_Min(float minHeight)
            {
                ShapeComponentConstraint constraint = new ShapeComponentConstraint
                {
                    Type          = ShapeComponentConstraintType.SurfaceHeight_Min,
                    Param_Float_0 = minHeight
                };

                return(constraint);
            }
            /// <summary>
            /// Constructs a constraint requiring the surface length to be between the given range.
            /// Length is the longer of the two bounding edges.
            /// </summary>
            /// <param name="minLength">Minimum surface length</param>
            /// <param name="maxLength">Maximum surface length</param>
            /// <returns>Constructed component constraint</returns>
            public static ShapeComponentConstraint Create_RectangleLength_Between(float minLength, float maxLength)
            {
                ShapeComponentConstraint constraint = new ShapeComponentConstraint
                {
                    Type          = ShapeComponentConstraintType.RectangleLength_Between,
                    Param_Float_0 = minLength,
                    Param_Float_1 = maxLength
                };

                return(constraint);
            }
 /// <summary>
 /// Constructs a constraint requiring the circle shaped component to have
 /// a radius between the given range
 /// </summary>
 /// <param name="minRadius">Minimum radius in meters</param>
 /// <param name="maxRadius">Maximum radius in meters</param>
 /// <returns>Constructed component constraint</returns>
 public static ShapeComponentConstraint Create_CircleRadius_Between(float minRadius, float maxRadius)
 {
     ShapeComponentConstraint constraint = new ShapeComponentConstraint();
     constraint.Type = ShapeComponentConstraintType.CircleRadius_Between;
     constraint.Param_Float_0 = minRadius;
     constraint.Param_Float_1 = maxRadius;
     return constraint;
 }
 /// <summary>
 /// Constructs a constraint requiring the component to be shaped like a circle
 /// 
 /// The squares similarity is the percent of the surface that matches the 
 /// containing circular component shape
 /// </summary>
 /// <param name="similarityMin">Minimum similarity to a circle</param>
 /// <returns>Constructed component constraint</returns>
 public static ShapeComponentConstraint Create_IsCircle(float similarityMin = 0.5f)
 {
     ShapeComponentConstraint constraint = new ShapeComponentConstraint();
     constraint.Type = ShapeComponentConstraintType.IsCircle;
     constraint.Param_Float_0 = similarityMin;
     return constraint;
 }
 /// <summary>
 /// Constructs a constraint requiring the component to have a specific surface area
 /// </summary>
 /// <param name="size">Required size in meters squared</param>
 /// <returns>Constructed component constraint</returns>
 public static ShapeComponentConstraint Create_SquareSize_Is(float size)
 {
     ShapeComponentConstraint constraint = new ShapeComponentConstraint();
     constraint.Type = ShapeComponentConstraintType.SquareSize_Is;
     constraint.Param_Float_0 = size;
     return constraint;
 }
 /// <summary>
 /// Constructs a constraint requiring the component to have a surface area
 /// between the given range
 /// </summary>
 /// <param name="minSize">Minimum size in meters squared</param>
 /// <param name="maxSize">Maximum size in meters squared</param>
 /// <returns>Constructed component constraint</returns>
 public static ShapeComponentConstraint Create_SquareSize_Between(float minSize, float maxSize)
 {
     ShapeComponentConstraint constraint = new ShapeComponentConstraint();
     constraint.Type = ShapeComponentConstraintType.SquareSize_Between;
     constraint.Param_Float_0 = minSize;
     constraint.Param_Float_1 = maxSize;
     return constraint;
 }
 /// <summary>
 /// Constructs a constraint requiring a specific surface width.
 /// Width is the shorter of the two bounding edges.
 /// </summary>
 /// <param name="width">Required surface width</param>
 /// <returns>Constructed component constraint</returns>
 public static ShapeComponentConstraint Create_RectangleWidth_Is(float width)
 {
     ShapeComponentConstraint constraint = new ShapeComponentConstraint();
     constraint.Type = ShapeComponentConstraintType.RectangleWidth_Is;
     constraint.Param_Float_0 = width;
     return constraint;
 }
 /// <summary>
 /// Constructs a constraint requiring the surface width to be between the given range.
 /// Width is the shorter of the two bounding edges.
 /// </summary>
 /// <param name="minWidth">Minimum surface width</param>
 /// <param name="maxWidth">Maximum surface width</param>
 /// <returns>Constructed component constraint</returns>
 public static ShapeComponentConstraint Create_RectangleWidth_Between(float minWidth, float maxWidth)
 {
     ShapeComponentConstraint constraint = new ShapeComponentConstraint();
     constraint.Type = ShapeComponentConstraintType.RectangleWidth_Between;
     constraint.Param_Float_0 = minWidth;
     constraint.Param_Float_1 = maxWidth;
     return constraint;
 }
 /// <summary>
 /// Constructs a constraint requiring the component to be within a height range above the floor
 /// </summary>
 /// <param name="minHeight">Minimum height above the floor</param>
 /// <param name="maxHeight">Maximum height above the floor</param>
 /// <returns>Constructed component constraint</returns>
 public static ShapeComponentConstraint Create_SurfaceHeight_Between(float minHeight, float maxHeight)
 {
     ShapeComponentConstraint constraint = new ShapeComponentConstraint();
     constraint.Type = ShapeComponentConstraintType.SurfaceHeight_Between;
     constraint.Param_Float_0 = minHeight;
     constraint.Param_Float_1 = maxHeight;
     return constraint;
 }
 /// <summary>
 /// Constructs a constraint requiring a minimum length and width of the surface rectangle. 
 /// Length is the longer of the two bounding edges and width the shorter edge.
 /// </summary>
 /// <param name="minLength">Minimum length</param>
 /// <param name="minWidth">Minimum width</param>
 /// <returns>Constructed component constraint</returns>
 public static ShapeComponentConstraint Create_RectangleSize_Min(float minLength, float minWidth)
 {
     ShapeComponentConstraint constraint = new ShapeComponentConstraint();
     constraint.Type = ShapeComponentConstraintType.RectangleSize_Min;
     constraint.Param_Float_0 = minLength;
     constraint.Param_Float_1 = minWidth;
     return constraint;
 }
 /// <summary>
 /// Constructs a constraint requiring the component to contain a specific surface area
 /// </summary>
 /// <param name="area">Required surface area</param>
 /// <returns>Constructed component constraint</returns>
 public static ShapeComponentConstraint Create_SurfaceArea_Is(float area)
 {
     ShapeComponentConstraint constraint = new ShapeComponentConstraint();
     constraint.Type = ShapeComponentConstraintType.SurfaceArea_Is;
     constraint.Param_Float_0 = area;
     return constraint;
 }
 /// <summary>
 /// Constructs a constraint requiring the component to contain a surface area
 /// between the range specified
 /// </summary>
 /// <param name="minArea">Minimum surface area</param>
 /// <param name="maxArea">Maximum surface area</param>
 /// <returns>Constructed component constraint</returns>
 public static ShapeComponentConstraint Create_SurfaceArea_Between(float minArea, float maxArea)
 {
     ShapeComponentConstraint constraint = new ShapeComponentConstraint();
     constraint.Type = ShapeComponentConstraintType.SurfaceArea_Between;
     constraint.Param_Float_0 = minArea;
     constraint.Param_Float_1 = maxArea;
     return constraint;
 }
 /// <summary>
 /// Constructs a constraint requiring the component to be a composed of a number of 
 /// discrete flat surfaces of the count specified
 /// </summary>
 /// <param name="count">Number of discrete surfaces</param>
 /// <returns>Constructed component constraint</returns>
 public static ShapeComponentConstraint Create_SurfaceCount_Is(int count)
 {
     ShapeComponentConstraint constraint = new ShapeComponentConstraint();
     constraint.Type = ShapeComponentConstraintType.SurfaceCount_Is;
     constraint.Param_Int_0 = count;
     return constraint;
 }
 /// <summary>
 /// Constructs a constraint requiring the component to be a composed of a number of 
 /// discrete flat surfaces between a specified range
 /// </summary>
 /// <param name="minCount">Minimum number of discrete surfaces</param>
 /// <param name="maxCount">Maximum number of discrete surfaces</param>
 /// <returns>Constructed component constraint</returns>
 public static ShapeComponentConstraint Create_SurfaceCount_Between(int minCount, int maxCount)
 {
     ShapeComponentConstraint constraint = new ShapeComponentConstraint();
     constraint.Type = ShapeComponentConstraintType.SurfaceCount_Between;
     constraint.Param_Int_0 = minCount;
     constraint.Param_Int_1 = maxCount;
     return constraint;
 }
 /// <summary>
 /// Constructs a constraint requiring the component to be a specific height above the floor
 /// </summary>
 /// <param name="height">Required height above the floor</param>
 /// <returns>Constructed component constraint</returns>
 public static ShapeComponentConstraint Create_SurfaceHeight_Is(float height)
 {
     ShapeComponentConstraint constraint = new ShapeComponentConstraint();
     constraint.Type = ShapeComponentConstraintType.SurfaceHeight_Is;
     constraint.Param_Float_0 = height;
     return constraint;
 }
 /// <summary>
 /// Constructs a constraint requiring the circle shaped component to have
 /// a specific radius
 /// </summary>
 /// <param name="radius">Required radius in meters</param>
 /// <returns>Constructed component constraint</returns>
 public static ShapeComponentConstraint Create_CircleRadius_Is(float radius)
 {
     ShapeComponentConstraint constraint = new ShapeComponentConstraint();
     constraint.Type = ShapeComponentConstraintType.CircleRadius_Is;
     constraint.Param_Float_0 = radius;
     return constraint;
 }
 /// <summary>
 /// Constructs a constraint requiring the component to not be a part of a specified shape
 /// </summary>
 /// <returns>Constructed component constraint</returns>
 public static ShapeComponentConstraint Create_SurfaceNotPartOfShape(string shapeName)
 {
     ShapeComponentConstraint constraint = new ShapeComponentConstraint();
     constraint.Type = ShapeComponentConstraintType.SurfaceNotPartOfShape;
     constraint.Param_Str_0 = SpatialUnderstanding.Instance.UnderstandingDLL.PinString(shapeName);
     return constraint;
 }
 /// <summary>
 /// Constructs a constraint requiring a maximum length.
 /// Length is the longer of the two bounding edges.
 /// </summary>
 /// <param name="maxLength">Maximum surface length</param>
 /// <returns>Constructed component constraint</returns>
 public static ShapeComponentConstraint Create_RectangleLength_Max(float maxLength)
 {
     ShapeComponentConstraint constraint = new ShapeComponentConstraint();
     constraint.Type = ShapeComponentConstraintType.RectangleLength_Max;
     constraint.Param_Float_0 = maxLength;
     return constraint;
 }