コード例 #1
0
    public void OnRenderObject()
    {
        if (textureHolder.GetTexture() == null)
        {
            return;
        }
        var texSize = new Vector2(textureHolder.GetTexture().width, textureHolder.GetTexture().height);

        var contours = finder.Contours;
        var area     = EMath.GetShrinkFitSize(texSize, screenSize);

        GL.PushMatrix();
        GL.MultMatrix(transform.localToWorldMatrix);
        material.SetPass(0);
        foreach (var contour in contours)
        {
            GL.Begin(GL.LINE_STRIP);
            GL.Color(color);
            var rect = OpenCVUtils.GetRect(contour);
            var p1   = OpenCVUtils.GetUnityCoordinateSystemPosition(new Vector2(rect.x, rect.y), texSize, area);
            var p2   = OpenCVUtils.GetUnityCoordinateSystemPosition(new Vector2(rect.x + rect.width, rect.y), texSize, area);
            var p3   = OpenCVUtils.GetUnityCoordinateSystemPosition(new Vector2(rect.x + rect.width, rect.y + rect.height), texSize, area);
            var p4   = OpenCVUtils.GetUnityCoordinateSystemPosition(new Vector2(rect.x, rect.y + rect.height), texSize, area);
            GL.Vertex3(p1.x, p1.y, this.transform.position.z);
            GL.Vertex3(p2.x, p2.y, this.transform.position.z);
            GL.Vertex3(p3.x, p3.y, this.transform.position.z);
            GL.Vertex3(p4.x, p4.y, this.transform.position.z);
            GL.Vertex3(p1.x, p1.y, this.transform.position.z);
            GL.End();
        }
        GL.PopMatrix();
    }
コード例 #2
0
    void Start()
    {
        var resolution = EMath.GetShrinkFitSize(correctableQuadController.Size, Vector2.one * maxResolution);

        renderTexture = new RenderTexture((int)resolution.x, (int)resolution.y, 24, RenderTextureFormat.ARGB32);
        correctableQuadController.Cam.targetTexture = renderTexture;
    }
コード例 #3
0
    public void Save()
    {
        var piList = new List <CorrectableQuad.PointInfomation>();

        for (var i = 0; i < Points.Length; i++)
        {
            var p  = Points[i];
            var uv = new Vector2(
                EMath.Map(p.x, -aspect.x / 2f, aspect.x / 2f, 0, 1),
                EMath.Map(p.y, -aspect.y / 2f, aspect.y / 2f, 0, 1)
                );
            var pi = new CorrectableQuad.PointInfomation
            {
                position = p,
                uv       = uv
            };
            piList.Add(pi);
            print(i + " : " + uv);
        }

        var setting = new QuadCorrectionSetting();

        setting.LeftTop     = new CorrectableQuad.JPointInfomation(piList[0]);
        setting.RightTop    = new CorrectableQuad.JPointInfomation(piList[1]);
        setting.RightBottom = new CorrectableQuad.JPointInfomation(piList[2]);
        setting.LeftBottom  = new CorrectableQuad.JPointInfomation(piList[3]);
        CorrectEvent?.Invoke(setting);
        IOHandler.SaveJson(IOHandler.IntoStreamingAssets(settingFileName), setting);
    }
コード例 #4
0
    private void VideoCaptureController_ChangeTextureEvent(TextureHolderBase sender, Texture texture)
    {
        var frameSize = new Vector2(camera.orthographicSize * 2 * camera.aspect, camera.orthographicSize * 2);
        var size      = EMath.GetShrinkFitSize(new Vector2(texture.width, texture.height), frameSize);

        this.transform.localScale     = new Vector3(size.x, size.y, 1f);
        renderer.material.mainTexture = textureHolder.GetTexture();
    }
コード例 #5
0
    public void Init(Vector2 size)
    {
        var h = captureCamera.orthographicSize * 2f;

        aspect = EMath.GetShrinkFitSize(size, new Vector2(h * captureCamera.aspect, h));
        renderer.transform.localScale = new Vector3(aspect.x, aspect.y, 1f);

        InitPoints();
        Restore();
    }
コード例 #6
0
ファイル: Function.cs プロジェクト: FacelessLord/Cat-lang
 protected Function(EMath <T> math, params Expression <T>[] args) : base(math)
 {
     Arguments = args;
     try
     {
     }
     catch (Exception e)
     {
         Console.WriteLine(e);
         throw;
     }
 }
コード例 #7
0
    private void Restore(QuadCorrectionSetting setting)
    {
        Size = fitToAngleOfView ? EMath.GetShrinkFitSize(this.destSize, new Vector2(cam.orthographicSize * 2f * cam.aspect, cam.orthographicSize * 2f)) : destSize;
        //print("size : " + Size);
        var lt = new Vector2(-Size.x / 2f, Size.y / 2f);
        var rt = new Vector2(Size.x / 2f, Size.y / 2f);
        var rb = new Vector2(Size.x / 2f, -Size.y / 2f);
        var lb = new Vector2(-Size.x / 2f, -Size.y / 2f);

        correctableQuad.Init(setting.LeftTop.ToPointInfomation(), setting.RightTop.ToPointInfomation(), setting.RightBottom.ToPointInfomation(), setting.LeftBottom.ToPointInfomation(),
                             segmentX, segmentY
                             );
        correctableQuad.Refresh(lt, rt, rb, lb);
    }
コード例 #8
0
        public void CalcCircumCenter()
        {
            float a, b, c;

            LineFromPoints(A, B, out a, out b, out c);
            float e, f, g;

            LineFromPoints(B, C, out e, out f, out g);

            PerpendicularBisectorFromLine(A, B, ref a, ref b, ref c);
            PerpendicularBisectorFromLine(B, C, ref e, ref f, ref g);

            CirC = lineLineIntersection(a, b, c, e, f, g);
            CirR = EMath.Len(A, CirC);
        }
コード例 #9
0
    IEnumerator ProcessRoutine()
    {
        while (index < files.Count)
        {
            var bytes = File.ReadAllBytes(files[index]);
            index++;
            texture.LoadImage(bytes);
            texture.Apply();
            renderer.transform.localPosition = Vector3.zero;
            renderer.material.mainTexture    = texture;
            var size = EMath.GetNormalizedExpandAspect(new Vector2(texture.width, texture.height));
            renderer.transform.localScale = new Vector3(size.x, size.y, 1f);
            localScale = renderer.transform.localScale;
            scaleRate  = 1f;
            isWaiting  = true;
            while (isWaiting)
            {
                yield return(null);
            }
            if (!isAllow)
            {
                continue;
            }

            captureCamera.Render();
            yield return(null);

            TextureUtils.RenderTexture2Texture2D(rt, resultTexture);
            var resultBytes = resultTexture.EncodeToJPG();
            var c           = count;
            if (dictionary.ContainsKey(index))
            {
                c = dictionary[index];
            }
            else
            {
                count++;
                c = count;
                dictionary.Add(index, c);
            }
            var path = Path.Combine(saveDirectory, (offsetIndex + c) + ".jpg");
            File.WriteAllBytes(path, resultBytes);
            var progress = ((float)index / files.Count);
            print(progress);
            yield return(null);
        }
        print("complete");
    }
コード例 #10
0
        public void Generate()
        {
            var eps = Mapper.Map <ApertureSequence, ExitPupilSequence>(this);

            eps.Generate();

            var epsHalf = eps.GetShallowCopy();

            epsHalf.ApertureIn = EMath.RInt(epsHalf.ApertureIn / 2);
            epsHalf.Generate();

            var epsDouble = eps.GetShallowCopy();

            epsDouble.ApertureIn = EMath.RInt(epsDouble.ApertureIn * 2);
            epsDouble.Generate();

            ExitPupilSequences.Clear();
            ExitPupilSequences.Add(epsDouble);
            ExitPupilSequences.Add(eps);
            ExitPupilSequences.Add(epsHalf);
        }
コード例 #11
0
    public void OnRenderObject()
    {
        if (textureHolder.GetTexture() == null)
        {
            return;
        }
        var texSize = new Vector2(textureHolder.GetTexture().width, textureHolder.GetTexture().height);

        var contours = finder.Contours;
        var area     = EMath.GetShrinkFitSize(texSize, screenSize);

        GL.PushMatrix();
        GL.MultMatrix(transform.localToWorldMatrix);

        material.SetPass(0);
        foreach (var contour in contours)
        {
            GL.Begin(GL.LINE_STRIP);
            GL.Color(color);
            var points = OpenCVUtils.MatOfPointToVector2List(contour);
            //OpenCVUtils.RemoveNearPoint(points, nearPointThreshold);
            Vector3 startPoint = Vector3.zero;
            for (var i = 0; i < points.Count; i++)
            {
                var pos = OpenCVUtils.GetUnityCoordinateSystemPosition(points[i], texSize, area);
                var p   = new Vector3(pos.x, pos.y, this.transform.position.z);
                GL.Vertex(p);
                if (i == 0)
                {
                    startPoint = p;
                }
            }
            GL.Vertex(startPoint);
            GL.End();
        }
        GL.PopMatrix();
    }
コード例 #12
0
    IEnumerator GenerateRoutine()
    {
        string[] files = Directory.GetFiles(loadDirectoryPath);
        files = files.Where(e => targetExtensions.Contains(Path.GetExtension(e))).ToArray();
        for (var i = 0; i < files.Length; i++)
        {
            var bytes = File.ReadAllBytes(files[i]);
            baseTexture.LoadImage(bytes);
            baseTexture.Apply();
            baseImageRenderer.material.mainTexture = baseTexture;
            var size = EMath.GetNormalizedExpandAspect(new Vector2(baseTexture.width, baseTexture.height));
            baseImageRenderer.transform.localScale = new Vector3(size.x, size.y, 1f);
            clampCamera.Render();
            yield return(null);

            //Aに画像をセット
            imageARenderer.material.mainTexture = clampedTexture;
            filterGroup.Filter(clampedTexture);
            yield return(null);

            var filteredTexture = filterGroup.GetTexture();
            imageBRenderer.material.mainTexture = filteredTexture;
            resultCamera.Render();
            yield return(null);

            TextureUtils.RenderTexture2Texture2D(resultRenderTexture, resultTexture);
            var resultBytes = resultTexture.EncodeToJPG();
            var path        = Path.Combine(saveDirectoryPath, (i + 1) + ".jpg");
            File.WriteAllBytes(path, resultBytes);
            var progress = ((float)i / files.Length);
            EditorUtility.DisplayProgressBar("Processing", "processing...", progress);
            yield return(null);
        }
        EditorUtility.ClearProgressBar();
        print("complete");
    }
コード例 #13
0
 public ApertureSequence(EMath eMath)
 {
     EMath = eMath;
     Mapper.CreateMap <ApertureSequence, ExitPupilSequence>();
 }
コード例 #14
0
  //画面上の位置を取得
  //一気にUnity上の画面の位置に変換する
 public static Vector2 GetUnityCoordinateSystemPosition(Vector2 position, Vector2 area1, Vector2 area2)
 {
     return(new Vector2(EMath.Map(position.x, 0f, area1.x, -area2.x / 2f, area2.x / 2f),
                        EMath.Map(position.y, 0f, area1.y, area2.y / 2f, -area2.y / 2f)));
 }
コード例 #15
0
 private void ResizeControl(ControlResizeParms crp, double widthRatio, double heightRatio)
 {
     crp.Control.Location = new Point(EMath.RInt(crp.Location.X * widthRatio), EMath.RInt(crp.Location.Y * heightRatio));
     crp.Control.Size     = new Size(EMath.RInt(crp.Size.Width * widthRatio), EMath.RInt(crp.Size.Height * heightRatio));
 }
コード例 #16
0
 public ResizeComponentProportionalStrategy(EMath eMath)
 {
     EMath = eMath;
     ListControlResizeParms = new List <ControlResizeParms>();
 }
コード例 #17
0
 //Unityの座標系に合わせて正規化された座標(-1~+1)
 public static Vector2 GetUnityCoordinateSystemNormalizedPosition(Vector2 position, Vector2 textureSize)
 {
     return(new Vector2(EMath.Map(position.x, 0f, textureSize.x, -1f, 1f),
                        EMath.Map(position.y, 0f, textureSize.y, 1f, -1f)));
 }
コード例 #18
0
 public Expression(EMath <T> math)
 {
     Math = math;
 }