Пример #1
0
 void insertPoint()
 {
     for (int i = pointCnt; i > 0; i--)
         points[i] = points[i - 1];
     points[0] = new Point(transform);
     pointCnt++;
 }
Пример #2
0
        /// <summary>
        /// 조절점 추가
        /// </summary>
        /// <param name="timeRatio"></param>
        /// <param name="value"></param>
        public void AddPoint(float timeRatio, float value)
        {
            var newp		= new Point { timeRatio = timeRatio, value = value };
            int datacount	= m_data.Count;
            if (datacount == 0)							// 케이스 1 - 데이터가 없는 경우 바로 추가
            {
                m_data.Add(newp);
            }
            else
            {											// 데이터가 하나 이상일 경우엔 인덱스를 직접 구한다
                var count		= m_data.Count;
                bool inserted	= false;
                for (int i = 0; i < count; i++)
                {
                    if (m_data[i].timeRatio > timeRatio)	// timeRatio가 더 큰 점을 찾는다면 바로 그 앞에 insert한다
                    {
                        m_data.Insert(i, newp);
                        inserted = true;
                    }
                }

                if (!inserted)							// 위 루프에서 점을 추가하지 못한 경우 맨 마지막에 추가
                {
                    m_data.Add(newp);
                }
            }
        }
Пример #3
0
        /**
         * A display object rig to access pan, rotation and zoom actions.
         * @param viewport the starting viewable rectangle including position
         * @param startPosition Point reprsenting the position that the camera will return to on reset
         * @param easingPan The value used to determine how much the camera should move each step towards its target in X and Y.
         * @param easingZoom The value used to determine how much the camera should move each step towards its target for scale.
         * @param easingRotate The value used to determine how much the camera should move each step towards its target for rotation.
         * @param boundingRect A Rectangle that constrains the movement of the camera
         */
        public CameraSprite(Rectangle viewport, Point startPosition=null, float easingPan=1f, float easingZoom=1f, float easingRotate=1, Rectangle boundingRect=null, Juggler juggler=null)
        {
            _juggler = juggler;

            _harness=new Harness();  // The harness is a container to manage rotation, scale and shaking without modifying the pivot and other properties of the main camera.
            _world=new World(this);

            _viewport=viewport;

            this.startPosition=startPosition;

            _easingPan=easingPan;
            _easingZoom=easingZoom;
            _easingRotate=easingRotate;

            if (boundingRect != null)
            {
                this.boundingRect=boundingRect;
            }
            else
            {
                this.boundingRect=NO_BOUNDS.toRectangle();
            }

            _harness.center=new Point(_viewport.x + _viewport.width / 2, _viewport.y + _viewport.height / 2);
            base.addChildAt(_harness, 0);
            _harness.addChild(_world);
        }
Пример #4
0
				// Use this for initialization
				void Start ()
				{


						Texture2D imgTexture = Resources.Load ("lena") as Texture2D;
			
						Mat img1Mat = new Mat (imgTexture.height, imgTexture.width, CvType.CV_8UC3);
						Utils.texture2DToMat (imgTexture, img1Mat);
						Debug.Log ("img1Mat dst ToString " + img1Mat.ToString ());

						Mat img2Mat = new Mat (imgTexture.height, imgTexture.width, CvType.CV_8UC3);
						Utils.texture2DToMat (imgTexture, img2Mat);
						Debug.Log ("img2Mat dst ToString " + img2Mat.ToString ());



						float angle = UnityEngine.Random.Range (0, 360), scale = 1.0f;

						Point center = new Point (img2Mat.cols () * 0.5f, img2Mat.rows () * 0.5f);

						Mat affine_matrix = Imgproc.getRotationMatrix2D (center, angle, scale);

						Imgproc.warpAffine (img1Mat, img2Mat, affine_matrix, img2Mat.size ());


						FeatureDetector detector = FeatureDetector.create (FeatureDetector.ORB);
						DescriptorExtractor extractor = DescriptorExtractor.create (DescriptorExtractor.ORB);

						MatOfKeyPoint keypoints1 = new MatOfKeyPoint ();
						Mat descriptors1 = new Mat ();

						detector.detect (img1Mat, keypoints1);
						extractor.compute (img1Mat, keypoints1, descriptors1);

						MatOfKeyPoint keypoints2 = new MatOfKeyPoint ();
						Mat descriptors2 = new Mat ();
		
						detector.detect (img2Mat, keypoints2);
						extractor.compute (img2Mat, keypoints2, descriptors2);


						DescriptorMatcher matcher = DescriptorMatcher.create (DescriptorMatcher.BRUTEFORCE_HAMMINGLUT);
						MatOfDMatch matches = new MatOfDMatch ();

						matcher.match (descriptors1, descriptors2, matches);


						Mat resultImg = new Mat ();

						Features2d.drawMatches (img1Mat, keypoints1, img2Mat, keypoints2, matches, resultImg);



						Texture2D texture = new Texture2D (resultImg.cols (), resultImg.rows (), TextureFormat.RGBA32, false);
		
						Utils.matToTexture2D (resultImg, texture);

						gameObject.GetComponent<Renderer> ().material.mainTexture = texture;

				}
Пример #5
0
        private void floodFill(Point startPoint, Biome parentBiome)
        {
            Queue<Point> queue = new Queue<Point>();
            HashSet<Point> queuedPoints = new HashSet<Point>();
            queue.Enqueue(startPoint);
            queuedPoints.Add(startPoint);

            Point currentPoint;
            BiomeMapPixel currentPixel;
            while (queue.Count > 0)
            {
                currentPoint = queue.Dequeue();
                currentPixel = m_data[currentPoint.y, currentPoint.x];
                if (currentPixel.GetPrimaryBiome() == parentBiome.Type)
                {
                    currentPixel.ParentBiome = parentBiome;
                    ++parentBiome.Size;
                    foreach (Point neighbour in currentPoint.Neighbours)
                    {
                        if (neighbour.IsInBounds(0, 0, Size, Size) && GetPixelAtPoint(neighbour).ParentBiome == null && !queuedPoints.Contains(neighbour))
                        {
                            queue.Enqueue(neighbour);
                            queuedPoints.Add(neighbour);
                        }
                    }
                }
            }
        }
Пример #6
0
        public virtual void Brush(Point pixel, Sprite image, Blend.BlendFunction blend)
        {
            pixel = pixel - new Point(image.pivot);
            
            Point grid, offset;
            
            Cells.Coords(pixel, out grid, out offset);
            
            var gw = Mathf.CeilToInt((image.rect.width  + offset.x) / Cells.CellWidth);
            var gh = Mathf.CeilToInt((image.rect.height + offset.y) / Cells.CellHeight);

            for (int y = 0; y < gh; ++y)
            {
                for (int x = 0; x < gw; ++x)
                {
                    IDrawing drawing;

                    Point cell = new Point(grid.x + x, grid.y + y);
                    
                    if (Cells.GetDefault(cell, out drawing, NewCell))
                    {
                        var point = new Point(x * Cells.CellWidth, y * Cells.CellHeight);

                        drawing.Brush(offset - point + image.pivot, image, blend);

                        Changed.Set(cell, true);
                    }
                }
            }
        }
 public SweepEvent(Point p, bool isLeft, PolygonType polygonType, SweepEvent otherSweepEvent, EdgeType edgeType)
 {
     this.p = p;
     this.isLeft = isLeft;
     this.polygonType = polygonType;
     this.otherSE = otherSweepEvent;
     this.edgeType = edgeType;
 }
Пример #8
0
        public virtual void Brush(Point offset, 
                                  Sprite image, 
                                  Blend.BlendFunction blend)
        {
            var rtrans = transform as RectTransform;

            Drawing.Brush(offset - (Point) rtrans.localPosition, image, blend);
        }
Пример #9
0
 public void SetToPoint(Point p)
 {
     currentPoint = p;
     if (currentPoint != null)
         transform.localPosition = currentPoint.transform.localPosition;
     else
         transform.localPosition = new Vector3(-10000, -10000, 0);
 }
Пример #10
0
        public TiledDrawing(Point cellsize, 
                            SparseGrid<IDrawing>.Constructor newCell = null)
        {
            Cells = new SparseGrid<IDrawing>(cellsize.x, cellsize.y);
            Changed = new SparseGrid<bool>(cellsize.x, cellsize.y);

            NewCell = newCell ?? NullCell;
        }
Пример #11
0
        public static Rectangle inflatePoint(Rectangle rect, Point pt)
        {
            rect.x -= pt.x;
            rect.y -= pt.y;
            rect.width += pt.x * 2;
            rect.height += pt.y * 2;

            return rect;
        }
Пример #12
0
 public void SetTransparency(bool b)
 {
     if (_sprite != null)
         _sprite.color = new Color(_sprite.color.r, _sprite.color.g, _sprite.color.b, (b) ? 0.5f : 1f);
     if (currentPoint != null)
         currentPoint.isPugalka = !b;
     if (b)
         currentPoint = null;
 }
Пример #13
0
        public bool Sample(Point pixel, out Color color)
        {
            pixel = pixel.Offset(Sprite.textureRect.position);

            Assert.IsTrue(Sprite.textureRect.Contains((Vector2) pixel), "Fill out of bounds!");

            color = Sprite.texture.GetPixel(pixel.x, pixel.y);

            return true;
        }
Пример #14
0
		public Room (int maxRoomSize, int minRoomSize, int cellSizeX, int cellSizeY, Point pos, int maxDistortion = 0)
		{
			connectedRooms = new List<int> ();
			this.pos = pos;
			this.width = Random.Range (minRoomSize, maxRoomSize);
			this.height = Random.Range (minRoomSize, maxRoomSize);

			map = new int[cellSizeX, cellSizeY];

			//Центрирование 
			int minBorderX = (cellSizeX - width) / 2;
			int maxBorderX = width + minBorderX;
			int minBorderY = (cellSizeY - height) / 2;
			int maxBorderY = height + minBorderY;

			//Генерация прямоугольника комнаты
			for (int i = 0; i != cellSizeX; i++) {
				for (int j = 0; j != cellSizeY; j++) {
					if ((j > minBorderY && j < maxBorderY) && (i > minBorderX && i < maxBorderX))
						map [i, j] = 1;
					else
						map [i, j] = 0;
				}
			}

			//Генерация ответвлений
			for (int i = 0; i != maxDistortion; i++) {
				//Стартовая координата 
				int startX = Random.Range (minBorderX, maxBorderX);
				int startY = Random.Range (minBorderY, maxBorderY);
				int stopX = Random.Range (maxBorderX, maxRoomSize);
				int stopY = Random.Range (maxBorderY, maxRoomSize);

				for (int x = startX; x != stopX; x++) {
					for (int y = startY; y != stopY; y++) {
						map [x, y] = 1;
					}
				}
			}

			for (int i = 0; i != cellSizeX; i++) {
				for (int j = 0; j != cellSizeY; j++) {
					if (map [i, j] == 1 && (
					       map [i + 1, j] == 0 ||
					       //map [i - 1, j] == 0 ||
						map [i, j + 1] == 0 ))
					       //map [i, j - 1] == 0))
						map [i, j] = 3;
				}
			}
		}
Пример #15
0
        public virtual void Fill(Point pixel, Color color)
        {
            IDrawing drawing;
            Point grid, offset;
            
            Cells.Coords(pixel, out grid, out offset);
            
            if (Cells.Get(grid, out drawing))
            {
                drawing.Fill(offset, color);

                Changed.Set(grid, true);
            }
        }
Пример #16
0
        public void Reset()
        {
            gameObject.SetActive(true);
            transform.right = Vector3.right;
            _lastSearchPathTime = -100f;
            delay = 2f;
            _currentPoint = null;
            _currentPath = new List<Point>();
            if (listStartPoints.Count > 0)
            {
                _currentPoint = listStartPoints[Random.Range(0, listStartPoints.Count)];
                transform.localPosition = _currentPoint.transform.localPosition;
            }

            _isActive = true;
        }
        // Use this for initialization
        void Start()
        {
            //srcMat
            Texture2D srcTexture = Resources.Load ("matchshapes") as Texture2D;
            Mat srcMat = new Mat (srcTexture.height, srcTexture.width, CvType.CV_8UC1);
            Utils.texture2DToMat (srcTexture, srcMat);
            Debug.Log ("srcMat.ToString() " + srcMat.ToString ());
            Imgproc.threshold (srcMat, srcMat, 127, 255, Imgproc.THRESH_BINARY);

            //dstMat
            Texture2D dstTexture = Resources.Load ("matchshapes") as Texture2D;
            Mat dstMat = new Mat (dstTexture.height, dstTexture.width, CvType.CV_8UC3);
            Utils.texture2DToMat (dstTexture, dstMat);
            Debug.Log ("dstMat.ToString() " + dstMat.ToString ());

            List<MatOfPoint> srcContours = new List<MatOfPoint> ();
            Mat srcHierarchy = new Mat ();

            /// Find srcContours
            Imgproc.findContours (srcMat, srcContours, srcHierarchy, Imgproc.RETR_CCOMP, Imgproc.CHAIN_APPROX_NONE);

            Debug.Log ("srcContours.Count " + srcContours.Count);

            for (int i=0; i<srcContours.Count; i++) {
                Imgproc.drawContours (dstMat, srcContours, i, new Scalar (255, 0, 0), 2, 8, srcHierarchy, 0, new Point ());
            }

            for (int i=0; i<srcContours.Count; i++) {
                double returnVal = Imgproc.matchShapes (srcContours [1], srcContours [i], Imgproc.CV_CONTOURS_MATCH_I1, 0);
                Debug.Log ("returnVal " + i + " " + returnVal);

                Point point = new Point ();
                float[] radius = new float[1];
                Imgproc.minEnclosingCircle (new MatOfPoint2f (srcContours [i].toArray ()), point, radius);
                Debug.Log ("point.ToString() " + point.ToString ());
                Debug.Log ("radius.ToString() " + radius [0]);

                Imgproc.circle (dstMat, point, 5, new Scalar (0, 0, 255), -1);
                Imgproc.putText (dstMat, " " + returnVal, point, Core.FONT_HERSHEY_SIMPLEX, 0.4, new Scalar (0, 255, 0), 1, Imgproc.LINE_AA, false);
            }

            Texture2D texture = new Texture2D (dstMat.cols (), dstMat.rows (), TextureFormat.RGBA32, false);

            Utils.matToTexture2D (dstMat, texture);

            gameObject.GetComponent<Renderer> ().material.mainTexture = texture;
        }
Пример #18
0
        private Dictionary<Vector3, Dictionary<Color, Dictionary<Vector3, Point>>> mesh_ = null; // = new Dictionary<Vector3, Point>();

        #endregion Fields

        #region Methods

        public static Dictionary<Vector3, Dictionary<Color, Dictionary<Vector3, Point>>> Draw2Mesh(VoxelDrawData draw)
        {
            Dictionary<Vector3, Dictionary<Color, Dictionary<Vector3, Point>>> mesh = new Dictionary<Vector3, Dictionary<Color, Dictionary<Vector3, Point>>>();// = new Dictionary<Vector3, Point>();

            List<VoxelDrawData.Vertice> vex = draw.vertices;

            for (int i = 0; i < vex.Count; ++i) {
                VoxelDrawData.Vertice v = vex[i];
                if (!mesh.ContainsKey (v.normal)) {
                    mesh [v.normal] = new Dictionary<Color, Dictionary<Vector3, Point>> ();
                }

                if (!mesh [v.normal].ContainsKey (v.color)) {
                    mesh [v.normal] [v.color]  = new Dictionary<Vector3, Point> ();

                }
                Point point = new Point ();
                point.vertice = v;
                mesh [v.normal] [v.color][v.position] = point;

            }

            List<int> trx = draw.triangles;

            for (int i = 0; i < trx.Count; i += 3) {
                VoxelDrawData.Vertice a = vex [trx [i]];
                VoxelDrawData.Vertice b = vex [trx [i+1]];
                VoxelDrawData.Vertice c = vex [trx [i+2]];
                Dictionary<Vector3, Point> m = mesh [a.normal] [a.color];

                Point A = m [a.position];
                Point B = m [b.position];
                Point C = m [c.position];

                A.link.Add (B);
                A.link.Add (C);

                B.link.Add (A);
                B.link.Add (C);

                C.link.Add (A);
                C.link.Add (B);
            }
            return mesh;
        }
Пример #19
0
 public virtual bool Sample(Point pixel, out Color color)
 {
     IDrawing drawing;
     Point grid, offset;
     
     Cells.Coords(pixel, out grid, out offset);
     
     if (Cells.Get(grid, out drawing))
     {
         return drawing.Sample(offset, out color);
     }
     else
     {
         color = Color.black;
         
         return false;
     }
 }
Пример #20
0
        public BiomeMap(TerrainGenerator newTerrainData)
        {
            m_terrainData = newTerrainData;
            m_data = new BiomeMapPixel[Size, Size];

            //Set biome weights for all pixels
            Point position;
            for (int x = 0; x < Size; ++x)
            {
                for (int y = 0; y < Size; ++y)
                {
                    position = new Point(x, y);

                    float heightAboveSeaLevel = m_terrainData.GetHeightAboveSeaLevelAt(position);
                    float latitude = Mathf.Clamp(position.y / (float)m_terrainData.Heightmap.size, 0f, 1f);
                    float precipitation = m_terrainData.Rainmap.GetValueAt(position);

                    m_data[y, x] = new BiomeMapPixel(latitude, heightAboveSeaLevel, precipitation);
                }
            }

            //Iterate through all pixels, setting their parent Biome
            for (int x = 0; x < Size; ++x)
            {
                for (int y = 0; y < Size; ++y)
                {
                    //Ignore pixels that have already had their parent biome set.
                    if (m_data[y, x].ParentBiome != null)
                    {
                        continue;
                    }

                    //Generate a new Biome object from the primary biome type of this pixel.
                    Biome biome = new Biome(m_data[y, x].GetPrimaryBiome());

                    //Flood fill the map with that biome.
                    floodFill(new Point(x, y), biome);

                    //Generate a name for that biome, now that it knows how big it is.
                    biome.GenerateName();
                }
            }
        }
Пример #21
0
        // Use this for initialization
        void Start()
        {
            Texture2D srcTexture = Resources.Load ("template") as Texture2D;
                        Texture2D dstTexture = Resources.Load ("lena") as Texture2D;
                        Mat src = new Mat (srcTexture.height, srcTexture.width, CvType.CV_8UC3);
                        Mat dst = new Mat (dstTexture.height, dstTexture.width, CvType.CV_8UC3);
                        Utils.texture2DToMat (srcTexture, src);
                        Utils.texture2DToMat (dstTexture, dst);

                        Mat mask = new Mat (src.rows (), src.cols (), CvType.CV_8UC1, new Scalar (255));
                        Mat result = new Mat ();

                        Point point = new Point (315, 450);
                        Photo.seamlessClone (src, dst, mask, point, result, Photo.NORMAL_CLONE);

                        Debug.Log ("result ToString " + result.ToString ());

                        Texture2D texture = new Texture2D (result.cols (), result.rows (), TextureFormat.RGBA32, false);

                        Utils.matToTexture2D (result, texture);

                        gameObject.GetComponent<Renderer> ().material.mainTexture = texture;
        }
Пример #22
0
        public static Brush Line(Point start,
                                 Point end,
                                 Color color, 
                                 int thickness)
        {
            var tl = new Point(Mathf.Min(start.x, end.x),
                               Mathf.Min(start.y, end.y));

            int left = Mathf.FloorToInt(thickness / 2f);

            Point size = (end - start).Size + new Point(thickness, thickness);
            var pivot  = tl * -1 + Vector2.one * left;
            var anchor = new Vector2(pivot.x / (float) size.x, pivot.y / (float) size.y);
            var rect   = new Rect(0, 0, size.x, size.y);

            Texture2D image = BlankTexture.New(size.x, size.y, Color.clear);
            Brush brush = new Brush(Sprite.Create(image, rect, anchor, 1));
            brush.sprite.name = "Line (Brush)";

            using (Brush circle = Circle(thickness, color))
            {
                Bresenham.PlotFunction plot = delegate (int x, int y)
                {
                    Apply(circle, new Point(x, y),
                          brush, Point.Zero,
                          Blend.Alpha);

                    return true;
                };

                Bresenham.Line(start.x, start.y, end.x, end.y, plot);
            }

            brush.sprite.texture.Apply();

            return brush;
        }
Пример #23
0
        public static void GetTriangle(Point point, List<Triangle> trx)
        {
            //a[normal][color][position]
            HashSet<Point> link = new HashSet<Point>();
            foreach (Point o in point.link) {
                link.Add (o);
            }
            foreach (Point o in point.link)
            {

                foreach(Point l in o.link){

                    if (link.Contains (l)) {
                        trx.Add(new Triangle (point, o, l));

                    }

                }
                link.Remove(o);
                o.link.Remove (point);

            }
            point.link.Clear ();
        }
Пример #24
0
        private void NewPosition(Point p)
        {
            Point prewPoint = _currentPoint;

            _currentPoint = p;
            _targetPoint = null;

            // Проверка на победу или проигрыш
            if (_currentPoint.isMousetrap)
            {
                MiniGame23_Manager.instance.KilledRat(this);
                return;
            }
            else if (_currentPoint.isCable)
            {
                MiniGame23_Manager.instance.EatCable(_currentPoint);
                return;
            }
            else if (_currentPoint.isPugalka)
            {
                if (_currentPath != null)
                    _currentPath.Clear();
                _targetPoint = prewPoint;
                return;
            }

            // Если нет пути, пытаемся найти
            if ((_currentPath == null || _currentPath.Count == 0) && Time.timeSinceLevelLoad - _lastSearchPathTime > 3f)
            {
                _lastSearchPathTime = Time.timeSinceLevelLoad;
                if (_currentPath == null)
                    _currentPath = new List<Point>();
                else _currentPath.Clear();
                List<Point> l = new List<Point>();
                if (!MiniGame23_Manager.instance.FindShorterPath(ref _currentPath, ref l, null, _currentPoint, pointFinish))
                    _currentPath.Clear();

                    //string s = "";
                    //foreach (Point pp in _currentPath)
                    //    s += pp.ToString() + "  ";
                    //Debug.Log(s);

            }

            // Если нашли, выбираем новую точку, к которой будем двигаться
            if (_currentPath != null && _currentPath.Count > 0)
            {
                if (_currentPath.Contains(_currentPoint))
                {
                    int index = _currentPath.IndexOf(_currentPoint);
                    if (_currentPath.Count > index + 1)
                    {
                        _targetPoint = _currentPath[index + 1];
                        //Debug.Log("true");
                    }
                }
                else _currentPath.Clear();
            }

            if (_targetPoint == null || _targetPoint.isPugalka)
            {
                if (_currentPath != null)
                    _currentPath.Clear();
                // Выбираем точки из текущей позиции, к которым можем двигаться и двигаемся к случайной
                List<Point> list = new List<Point>();
                foreach (Point point in _currentPoint.listPoints)
                    if (!point.isPugalka && point != _currentPoint)
                        list.Add(point);

                //Debug.Log(list.Count);
                if (list.Count > 1)
                    if (list.Contains(prewPoint))
                        list.Remove(prewPoint);

                if (list.Count > 0)
                    _targetPoint = list[Random.Range(0, list.Count)];
                else _targetPoint = null;
            }
        }
        /// <summary>
        /// Converts the screen point.
        /// </summary>
        /// <returns>The screen point.</returns>
        /// <param name="screenPoint">Screen point.</param>
        /// <param name="quad">Quad.</param>
        /// <param name="cam">Cam.</param>
        static Point convertScreenPoint(Point screenPoint, GameObject quad, Camera cam)
        {
            Vector2 tl;
                        Vector2 tr;
                        Vector2 br;
                        Vector2 bl;

                        tl = cam.WorldToScreenPoint (new Vector3 (quad.transform.localPosition.x - quad.transform.localScale.x / 2, quad.transform.localPosition.y + quad.transform.localScale.y / 2, quad.transform.localPosition.z));
                        tr = cam.WorldToScreenPoint (new Vector3 (quad.transform.localPosition.x + quad.transform.localScale.x / 2, quad.transform.localPosition.y + quad.transform.localScale.y / 2, quad.transform.localPosition.z));
                        br = cam.WorldToScreenPoint (new Vector3 (quad.transform.localPosition.x + quad.transform.localScale.x / 2, quad.transform.localPosition.y - quad.transform.localScale.y / 2, quad.transform.localPosition.z));
                        bl = cam.WorldToScreenPoint (new Vector3 (quad.transform.localPosition.x - quad.transform.localScale.x / 2, quad.transform.localPosition.y - quad.transform.localScale.y / 2, quad.transform.localPosition.z));

                        Mat srcRectMat = new Mat (4, 1, CvType.CV_32FC2);
                        Mat dstRectMat = new Mat (4, 1, CvType.CV_32FC2);

                        srcRectMat.put (0, 0, tl.x, tl.y, tr.x, tr.y, br.x, br.y, bl.x, bl.y);
                        dstRectMat.put (0, 0, 0.0, 0.0, quad.transform.localScale.x, 0.0, quad.transform.localScale.x, quad.transform.localScale.y, 0.0, quad.transform.localScale.y);

                        Mat perspectiveTransform = Imgproc.getPerspectiveTransform (srcRectMat, dstRectMat);

                        //						Debug.Log ("srcRectMat " + srcRectMat.dump ());
                        //						Debug.Log ("dstRectMat " + dstRectMat.dump ());
                        //						Debug.Log ("perspectiveTransform " + perspectiveTransform.dump ());

                        MatOfPoint2f srcPointMat = new MatOfPoint2f (screenPoint);
                        MatOfPoint2f dstPointMat = new MatOfPoint2f ();

                        Core.perspectiveTransform (srcPointMat, dstPointMat, perspectiveTransform);

                        //						Debug.Log ("srcPointMat " + srcPointMat.dump ());
                        //						Debug.Log ("dstPointMat " + dstPointMat.dump ());

                        return dstPointMat.toArray () [0];
        }
Пример #26
0
 public void Fill(Point pixel, Color color)
 {
     Sprite.texture.FloodFillAreaNPO2(pixel.x, pixel.y, 
                                      color, 
                                      Sprite.textureRect);
 }
Пример #27
0
 public void Brush(Point offset, Sprite image, Blend.BlendFunction blend)
 {
     PixelDraw.Brush.Apply(image,  offset,
                           Sprite, new Point(0, 0),
                           blend);
 }
Пример #28
0
        void Update()
        {
            if (emit && emitTime > 0)
            {
                emitTime -= Time.deltaTime;
                if (emitTime < 0.001) emit = false;
            }

            if (!emit && points.Count == 0 && autoDestruct)
            {
                Destroy(o);
            }

            // early out if there is no camera
            if (!Camera.main) return;

            bool re = false;

            // if we have moved enough, create a new vertex and make sure we rebuild the mesh
            float theDistance = (_lastPosition - transform.position).magnitude;
            if (emit)
            {
                if (theDistance > minVertexDistance)
                {
                    bool make = false;
                    if (points.Count < 3)
                    {
                        make = true;
                    }
                    else
                    {
                        Vector3 l1 = ((Point)points[points.Count - 2]).Position - ((Point)points[points.Count - 3]).Position;
                        Vector3 l2 = ((Point)points[points.Count - 1]).Position - ((Point)points[points.Count - 2]).Position;
                        if (Vector3.Angle(l1, l2) > maxAngle || theDistance > maxVertexDistance) make = true;
                    }

                    if (make)
                    {
                        Point p = new Point();
                        p.Position = transform.position;
                        p.TimeCreated = Time.time;
                        points.Add(p);
                        _lastPosition = transform.position;
                    }
                    else
                    {
                        ((Point)points[points.Count - 1]).Position = transform.position;
                        ((Point)points[points.Count - 1]).TimeCreated = Time.time;
                    }
                }
                else if (points.Count > 0)
                {
                    ((Point)points[points.Count - 1]).Position = transform.position;
                    ((Point)points[points.Count - 1]).TimeCreated = Time.time;
                }
            }

            if (!emit && _lastFrameEmit && points.Count > 0) ((Point)points[points.Count - 1]).LineBreak = true;
            _lastFrameEmit = emit;

            // approximate if we should rebuild the mesh or not
            if (points.Count > 1)
            {
                Vector3 cur1 = Camera.main.WorldToScreenPoint(((Point)points[0]).Position);
                _lastCameraPosition1.z = 0;
                Vector3 cur2 = Camera.main.WorldToScreenPoint(((Point)points[points.Count - 1]).Position);
                _lastCameraPosition2.z = 0;

                float distance = (_lastCameraPosition1 - cur1).magnitude;
                distance += (_lastCameraPosition2 - cur2).magnitude;

                if (distance > movePixelsForRebuild || Time.time - _lastRebuildTime > maxRebuildTime)
                {
                    re = true;
                    _lastCameraPosition1 = cur1;
                    _lastCameraPosition2 = cur2;
                }
            }
            else
            {
                re = true;
            }

            if (re)
            {
                _lastRebuildTime = Time.time;

                ArrayList remove = new ArrayList();
                int i = 0;
                foreach (Point p in points)
                {
                    // cull old points first
                    if (Time.time - p.TimeCreated > lifeTime) remove.Add(p);
                    i++;
                }

                foreach (Point p in remove) points.Remove(p);
                remove.Clear();

                if (points.Count > 1)
                {
                    Vector3[] newVertices = new Vector3[points.Count * 2];
                    Vector2[] newUV = new Vector2[points.Count * 2];
                    int[] newTriangles = new int[(points.Count - 1) * 6];
                    Color[] newColors = new Color[points.Count * 2];

                    i = 0;
                    float curDistance = 0.00f;

                    foreach (Point p in points)
                    {
                        float time = (Time.time - p.TimeCreated) / lifeTime;

                        Color color = Color.Lerp(Color.white, Color.clear, time);
                        if (Colors != null && Colors.Length > 0)
                        {
                            float colorTime = time * (Colors.Length - 1);
                            float min = Mathf.Floor(colorTime);
                            float max = Mathf.Clamp(Mathf.Ceil(colorTime), 1, Colors.Length - 1);
                            float lerp = Mathf.InverseLerp(min, max, colorTime);
                            if (min >= Colors.Length) min = Colors.Length - 1; if (min < 0) min = 0;
                            if (max >= Colors.Length) max = Colors.Length - 1; if (max < 0) max = 0;
                            color = Color.Lerp(Colors[(int)min], Colors[(int)max], lerp);
                        }

                        float size = 1f;
                        if (Sizes != null && Sizes.Length > 0)
                        {
                            float sizeTime = time * (Sizes.Length - 1);
                            float min = Mathf.Floor(sizeTime);
                            float max = Mathf.Clamp(Mathf.Ceil(sizeTime), 1, Sizes.Length - 1);
                            float lerp = Mathf.InverseLerp(min, max, sizeTime);
                            if (min >= Sizes.Length) min = Sizes.Length - 1; if (min < 0) min = 0;
                            if (max >= Sizes.Length) max = Sizes.Length - 1; if (max < 0) max = 0;
                            size = Mathf.Lerp(Sizes[(int)min], Sizes[(int)max], lerp);
                        }

                        Vector3 perpendicular = Vector3.up;//Vector3.Cross(lineDirection, vectorToCamera).normalized;

                        newVertices[i * 2] = p.Position + (perpendicular * (size * 0.5f));
                        newVertices[(i * 2) + 1] = p.Position + (-perpendicular * (size * 0.5f));

                        newColors[i * 2] = newColors[(i * 2) + 1] = color;

                        newUV[i * 2] = new Vector2(curDistance * UvLengthScale, 0);
                        newUV[(i * 2) + 1] = new Vector2(curDistance * UvLengthScale, 1);

                        if (i > 0 && !((Point)points[i - 1]).LineBreak)
                        {
                            if (HigherQualityUVs) curDistance += (p.Position - ((Point)points[i - 1]).Position).magnitude;
                            else curDistance += (p.Position - ((Point)points[i - 1]).Position).sqrMagnitude;

                            newTriangles[(i - 1) * 6] = (i * 2) - 2;
                            newTriangles[((i - 1) * 6) + 1] = (i * 2) - 1;
                            newTriangles[((i - 1) * 6) + 2] = i * 2;

                            newTriangles[((i - 1) * 6) + 3] = (i * 2) + 1;
                            newTriangles[((i - 1) * 6) + 4] = i * 2;
                            newTriangles[((i - 1) * 6) + 5] = (i * 2) - 1;
                        }

                        i++;
                    }

                    if (o != null)
                    {
                        Mesh mesh = (o.GetComponent<MeshFilter>() as MeshFilter).mesh;
                        mesh.Clear();
                        mesh.vertices = newVertices;
                        mesh.colors = newColors;
                        mesh.uv = newUV;
                        mesh.triangles = newTriangles;
                    }
                }
            }
        }
				/// <summary>
				/// Init this instance.
				/// </summary>
				private IEnumerator init ()
				{
						if (webCamTexture != null) {
								webCamTexture.Stop ();
								initDone = false;
				
								rgbaMat.Dispose ();
						}

						// Checks how many and which cameras are available on the device
						for (int cameraIndex = 0; cameraIndex < WebCamTexture.devices.Length; cameraIndex++) {
				
				
								if (WebCamTexture.devices [cameraIndex].isFrontFacing == isFrontFacing) {
					
					
										Debug.Log (cameraIndex + " name " + WebCamTexture.devices [cameraIndex].name + " isFrontFacing " + WebCamTexture.devices [cameraIndex].isFrontFacing);

										webCamDevice = WebCamTexture.devices [cameraIndex];
										
										webCamTexture = new WebCamTexture (webCamDevice.name, width, height);
					
					
										break;
								}
				
				
						}

						if (webCamTexture == null) {
								webCamDevice = WebCamTexture.devices [0];
								webCamTexture = new WebCamTexture (webCamDevice.name, width, height);
						}
			
						Debug.Log ("width " + webCamTexture.width + " height " + webCamTexture.height + " fps " + webCamTexture.requestedFPS);
			
			
			
						// Starts the camera
						webCamTexture.Play ();

						while (true) {
								//If you want to use webcamTexture.width and webcamTexture.height on iOS, you have to wait until webcamTexture.didUpdateThisFrame == 1, otherwise these two values will be equal to 16. (http://forum.unity3d.com/threads/webcamtexture-and-error-0x0502.123922/)
								#if UNITY_IOS && !UNITY_EDITOR && (UNITY_4_6_3 || UNITY_4_6_4 || UNITY_5_0_0 || UNITY_5_0_1)
				if (webCamTexture.width > 16 && webCamTexture.height > 16) {
								#else
								if (webCamTexture.didUpdateThisFrame) {
										#endif
										Debug.Log ("width " + webCamTexture.width + " height " + webCamTexture.height + " fps " + webCamTexture.requestedFPS);
										Debug.Log ("videoRotationAngle " + webCamTexture.videoRotationAngle + " videoVerticallyMirrored " + webCamTexture.videoVerticallyMirrored + " isFrongFacing " + webCamDevice.isFrontFacing);

					
										colors = new Color32[webCamTexture.width * webCamTexture.height];
					
										rgbaMat = new Mat (webCamTexture.height, webCamTexture.width, CvType.CV_8UC4);
					
										texture = new Texture2D (webCamTexture.width, webCamTexture.height, TextureFormat.RGBA32, false);
					

					
										gameObject.transform.localEulerAngles = new Vector3 (0, 0, 0);
//										gameObject.transform.rotation = gameObject.transform.rotation * Quaternion.AngleAxis (webCamTexture.videoRotationAngle, Vector3.back);
					

										gameObject.transform.localScale = new Vector3 (webCamTexture.width, webCamTexture.height, 1);

//										bool videoVerticallyMirrored = webCamTexture.videoVerticallyMirrored;
//										float scaleX = 1;
//										float scaleY = videoVerticallyMirrored ? -1.0f : 1.0f;
//										gameObject.transform.localScale = new Vector3 (scaleX * gameObject.transform.localScale.x, scaleY * gameObject.transform.localScale.y, 1);

					
										gameObject.GetComponent<Renderer> ().material.mainTexture = texture;


										Camera.main.orthographicSize = webCamTexture.height / 2;





										//set cameraparam
										int max_d = Mathf.Max (rgbaMat.rows (), rgbaMat.cols ());
										camMatrix = new Mat (3, 3, CvType.CV_64FC1);
										camMatrix.put (0, 0, max_d);
										camMatrix.put (0, 1, 0);
										camMatrix.put (0, 2, rgbaMat.cols () / 2.0f);
										camMatrix.put (1, 0, 0);
										camMatrix.put (1, 1, max_d);
										camMatrix.put (1, 2, rgbaMat.rows () / 2.0f);
										camMatrix.put (2, 0, 0);
										camMatrix.put (2, 1, 0);
										camMatrix.put (2, 2, 1.0f);
										Debug.Log ("camMatrix " + camMatrix.dump ());

										distCoeffs = new MatOfDouble (0, 0, 0, 0);
										Debug.Log ("distCoeffs " + distCoeffs.dump ());

										//calibration camera
										Size imageSize = new Size (rgbaMat.cols (), rgbaMat.rows ());
										double apertureWidth = 0;
										double apertureHeight = 0;
										double[] fovx = new double[1];
										double[] fovy = new double[1];
										double[] focalLength = new double[1];
										Point principalPoint = new Point ();
										double[] aspectratio = new double[1];


										Calib3d.calibrationMatrixValues (camMatrix, imageSize, apertureWidth, apertureHeight, fovx, fovy, focalLength, principalPoint, aspectratio);

										Debug.Log ("imageSize " + imageSize.ToString ());
										Debug.Log ("apertureWidth " + apertureWidth);
										Debug.Log ("apertureHeight " + apertureHeight);
										Debug.Log ("fovx " + fovx [0]);
										Debug.Log ("fovy " + fovy [0]);
										Debug.Log ("focalLength " + focalLength [0]);
										Debug.Log ("principalPoint " + principalPoint.ToString ());
										Debug.Log ("aspectratio " + aspectratio [0]);

										//Adjust Unity Camera FOV
										for (int i = 0; i < ARCamera.Length; i++) {
												ARCamera [i].fieldOfView = (float)fovy [0];
										}
										

										
					
										markerDetector = new MarkerDetector (camMatrix, distCoeffs);


										//Marker Coordinate Initial Matrix
										lookAtM = getLookAtMatrix (new Vector3 (0, 0, 0), new Vector3 (0, 0, 1), new Vector3 (0, -1, 0));
										Debug.Log ("lookAt " + lookAtM.ToString ());

										//OpenGL to Unity Coordinate System Convert Matrix
										//http://docs.unity3d.com/ScriptReference/Camera-worldToCameraMatrix.html that camera space matches OpenGL convention: camera's forward is the negative Z axis. This is different from Unity's convention, where forward is the positive Z axis.
										invertZM = Matrix4x4.TRS (Vector3.zero, Quaternion.identity, new Vector3 (1, 1, -1));
										Debug.Log ("invertZM " + invertZM.ToString ());


					
										initDone = true;
					
										break;
								} else {
										yield return 0;
								}
						}
				}
		
				// Update is called once per frame
				void Update ()
				{
						if (!initDone)
								return;

						#if UNITY_IOS && !UNITY_EDITOR && (UNITY_4_6_3 || UNITY_4_6_4 || UNITY_5_0_0 || UNITY_5_0_1)
				if (webCamTexture.width > 16 && webCamTexture.height > 16) {
						#else
						if (webCamTexture.didUpdateThisFrame) {
								#endif
								
				
								Utils.webCamTextureToMat (webCamTexture, rgbaMat, colors);

								//flip to correct direction.
								if (webCamTexture.videoVerticallyMirrored) {
										if (webCamDevice.isFrontFacing) {
												if (webCamTexture.videoRotationAngle == 0) {
														Core.flip (rgbaMat, rgbaMat, -1);
												} else if (webCamTexture.videoRotationAngle == 180) {
														Core.flip (rgbaMat, rgbaMat, 0);
												}
										} else {
												if (webCamTexture.videoRotationAngle == 0) {
									
												} else if (webCamTexture.videoRotationAngle == 180) {
														Core.flip (rgbaMat, rgbaMat, 1);
												}
										}
								} else {
										if (webCamDevice.isFrontFacing) {
												if (webCamTexture.videoRotationAngle == 0) {
														Core.flip (rgbaMat, rgbaMat, 1);
												} else if (webCamTexture.videoRotationAngle == 180) {
														Core.flip (rgbaMat, rgbaMat, 0);
												}
										} else {
												if (webCamTexture.videoRotationAngle == 0) {
									
												} else if (webCamTexture.videoRotationAngle == 180) {
														Core.flip (rgbaMat, rgbaMat, -1);
												}
										}
								}
				
								markerDetector.processFrame (rgbaMat, 1);

								//Debug.Log ("markerDetector.getTransformations ().Count " + markerDetector.getTransformations ().Count);


								for (int i = 0; i < ARCamera.Length; i++) {
										ARCamera [i].gameObject.SetActive (false);
								}

								int markerCount = markerDetector.getTransformations ().Count;
								for (int i = 0; i < markerCount; i++) {
										if (i > ARCamera.Length - 1)
												break;
									
										ARCamera [i].gameObject.SetActive (true);

										//Marker to Camera Coordinate System Convert Matrix
										transformationM = markerDetector.getTransformations () [i];
										//Debug.Log ("transformationM " + transformationM.ToString ());
				
										worldToCameraM = lookAtM * transformationM * invertZM;
										//Debug.Log ("worldToCameraM " + worldToCameraM.ToString ());
				
										ARCamera [i].worldToCameraMatrix = worldToCameraM;
								}
							
				
								Utils.matToTexture2D (rgbaMat, texture, colors);
				
								gameObject.GetComponent<Renderer> ().material.mainTexture = texture;
				
				
						}
			
				}
		
				void OnDisable ()
				{
						webCamTexture.Stop ();
				}

				/// <summary>
				/// Gets the look at matrix.
				/// </summary>
				/// <returns>The look at matrix.</returns>
				/// <param name="pos">Position.</param>
				/// <param name="target">Target.</param>
				/// <param name="up">Up.</param>
				private Matrix4x4 getLookAtMatrix (Vector3 pos, Vector3 target, Vector3 up)
				{
			
						Vector3 z = Vector3.Normalize (pos - target);
						Vector3 x = Vector3.Normalize (Vector3.Cross (up, z));
						Vector3 y = Vector3.Normalize (Vector3.Cross (z, x));
			
						Matrix4x4 result = new Matrix4x4 ();
						result.SetRow (0, new Vector4 (x.x, x.y, x.z, -(Vector3.Dot (pos, x))));
						result.SetRow (1, new Vector4 (y.x, y.y, y.z, -(Vector3.Dot (pos, y))));
						result.SetRow (2, new Vector4 (z.x, z.y, z.z, -(Vector3.Dot (pos, z))));
						result.SetRow (3, new Vector4 (0, 0, 0, 1));
			
						return result;
				}

				void OnGUI ()
				{
						float screenScale = Screen.height / 240.0f;
						Matrix4x4 scaledMatrix = Matrix4x4.Scale (new Vector3 (screenScale, screenScale, screenScale));
						GUI.matrix = scaledMatrix;
			
			
						GUILayout.BeginVertical ();
			
						if (GUILayout.Button ("back")) {
								Application.LoadLevel ("MarkerBasedARSample");
						}
						if (GUILayout.Button ("change camera")) {
								isFrontFacing = !isFrontFacing;
								StartCoroutine (init ());
						}
			
						GUILayout.EndVertical ();
				}
		}
Пример #30
0
 public Triangle(Point a, Point b, Point c)
 {
     a_ = a;
     b_ = b;
     c_ = c;
 }