Esempio n. 1
0
 private void SetLight(eMagType mag_type)
 {
     if (mag_type == eMagType.MaxMag)
     {
         _camera.IntstSet(0, _maxMagIntensity);
     }
     else
     {
         _camera.IntstSet(0, _minMagIntensity);
     }
 }
Esempio n. 2
0
 public void ToMagPos(eMagType mag_type)
 {
     if (_cur_mag == mag_type)
     {
         _log.Debug("ToMagPos at the right pos");
         return;
     }
     try
     {
         _log.Debug("ToMagPos:" + Thread.CurrentThread.ManagedThreadId);
         MoveEventArgs moveEventArgs;
         if (mag_type == eMagType.MaxMag)
         {
             _camera.MaxMagSet();
             moveEventArgs = new MoveEventArgs('Z', _maxMagFocusPos, false);
         }
         else
         {
             _camera.MinMagSet();
             moveEventArgs = new MoveEventArgs('Z', _minMagFocusPos, false);
         }
         AsyncMove(this, moveEventArgs);
         AsyncMoveWait();
         SetLight(mag_type);
         _cur_mag = mag_type;
     }
     catch (Exception ex)
     {
         _cur_mag = eMagType.UnknownMag;
         SynOpErrorArgs arg = new SynOpErrorArgs();
         arg.Ex      = ex;
         arg.Message = "SynOp.ToMagPos()";
         FindAngleOK = false;
         OnError(this, arg);
     }
 }
Esempio n. 3
0
        private void AutoLight(eMagType mag_type)
        {
            int beginIntst, endIntst, intstId, intstNo, intstIdMax, intstIdMin;

            IAsyncResult[] result;
            int[]          runIntst;
            double[]       variance;
            double         maxVariance, minVariance;

            Object[] runImage;

            beginIntst = 55;
            endIntst   = 255;
            intstNo    = (endIntst - beginIntst) / 10 + 1;

            runIntst = new int[intstNo];
            result   = new IAsyncResult[intstNo];
            variance = new double[intstNo];
            runImage = new Object[intstNo];

            for (int intst = beginIntst, i = 0; intst <= endIntst; intst += 10, i++)
            {
                runIntst[i] = intst;

                _camera.IntstSet(0, intst);

                imageFilterDone.Reset();
                _camera.FilterImage(intst, 1);
                imageFilterDone.WaitOne();

                runImage[i] = ImgMat;

                result[i] = computeLightScoreDelegate.BeginInvoke(runImage[i], null, null);
            }

            for (int i = 0; i < intstNo; i++)
            {
                result[i].AsyncWaitHandle.WaitOne();
                variance[i] = computeLightScoreDelegate.EndInvoke(result[i]);
                result[i].AsyncWaitHandle.Close();
            }

            intstIdMax  = intstIdMin = 0;
            maxVariance = minVariance = variance[0];
            for (int i = 0; i < intstNo; i++)
            {
                Console.WriteLine("variance[" + i + "]: " + variance[i] + ", intst: " + runIntst[i]);
                if (variance[i] > maxVariance)
                {
                    maxVariance = variance[i];
                    intstIdMax  = i;
                }
                else if (variance[i] < minVariance)
                {
                    minVariance = variance[i];
                    intstIdMin  = i;
                }
            }
            intstId = intstIdMax;

            //ColorHistShow((Mat)runImage[intstId]);

            for (int i = 0; i < intstNo; i++)
            {
                ((Mat)runImage[i]).Dispose();
            }

            _camera.IntstSet(0, runIntst[intstId]);
            if (mag_type == eMagType.MaxMag)
            {
                _maxMagIntensity = runIntst[intstId];
            }
            else
            {
                _minMagIntensity = runIntst[intstId];
            }

            Console.WriteLine("intst id: " + intstId + ", intst: " + runIntst[intstId] + ", variance: " + variance[intstId]);
        }
Esempio n. 4
0
        private void MagAutoFocus(eMagType mag_type)
        {
            int           beginPosition, endPosition, positionNo, positionId;
            MoveEventArgs moveEventArgs;

            int[]          runPosition;
            IAsyncResult[] result;
            double[]       variance;
            double         maxVariance;

            Object[] runImage;

            _log.Debug("Auto Focusing First Run(" + mag_type + ":" + Thread.CurrentThread.ManagedThreadId);

            try
            {
                if (mag_type == eMagType.MaxMag)
                {
                    beginPosition = _paraReader.MaxMagAutoFocusBegin;
                    endPosition   = _paraReader.MaxMagAutoFocusEnd;
                    _camera.MaxMagSet();
                }
                else
                {
                    beginPosition = _paraReader.MinMagAutoFocusBegin;
                    endPosition   = _paraReader.MinMagAutoFocusEnd;
                    _camera.MinMagSet();
                }

                positionNo = (Math.Abs(endPosition - beginPosition)) / 100 + 1;

                minAFFuncMs = Int32.MaxValue;
                maxAFFuncMs = 0;

                runPosition = new int[positionNo];
                result      = new IAsyncResult[positionNo];
                variance    = new double[positionNo];
                runImage    = new Object[positionNo];

                for (int position = beginPosition, i = 0; position <= endPosition; position += 100, i++)
                {
                    runPosition[i] = position;
                    moveEventArgs  = new MoveEventArgs('Z', position, false);
                    AsyncMove(this, moveEventArgs);
                    AsyncMoveWait();

                    imageFilterDone.Reset();
                    _camera.FilterImage(position, 1);
                    imageFilterDone.WaitOne();

                    runImage[i] = ImgMat;

                    result[i] = computeFocusScoreDelegate.BeginInvoke(runImage[i], null, null);
                }

                for (int i = 0; i < positionNo; i++)
                {
                    result[i].AsyncWaitHandle.WaitOne();
                    variance[i] = computeFocusScoreDelegate.EndInvoke(result[i]);
                    result[i].AsyncWaitHandle.Close();
                }

                maxVariance = variance[0];
                positionId  = 0;
                for (int i = 0; i < positionNo; i++)
                {
                    Console.WriteLine("variance[" + i + "]= " + variance[i]);
                    if (variance[i] > maxVariance)
                    {
                        maxVariance = variance[i];
                        positionId  = i;
                    }
                }

                _log.Debug("position id: " + positionId + ", position: " + runPosition[positionId] + ", variance: " + variance[positionId]);

                _log.Debug("Auto Focusing Second Run:");

                if (positionId == 0)
                {
                    beginPosition = runPosition[0];
                }
                else
                {
                    beginPosition = runPosition[positionId - 1];
                }

                if (positionId == positionNo - 1)
                {
                    endPosition = runPosition[positionNo - 1];
                }
                else
                {
                    endPosition = runPosition[positionId + 1];
                }

                positionNo = (Math.Abs(endPosition - beginPosition)) / 10 + 1;

                runPosition = new int[positionNo];
                result      = new IAsyncResult[positionNo];
                variance    = new double[positionNo];
                runImage    = new Object[positionNo];

                for (int position = beginPosition, i = 0; position <= endPosition; position += 10, i++)
                {
                    runPosition[i] = position;
                    moveEventArgs  = new MoveEventArgs('Z', position, false);
                    AsyncMove(this, moveEventArgs);
                    AsyncMoveWait();

                    imageFilterDone.Reset();
                    _camera.FilterImage(position, 1);
                    imageFilterDone.WaitOne();

                    runImage[i] = ImgMat;

                    result[i] = computeFocusScoreDelegate.BeginInvoke(runImage[i], null, null);
                }

                for (int i = 0; i < positionNo; i++)
                {
                    result[i].AsyncWaitHandle.WaitOne();
                    variance[i] = computeFocusScoreDelegate.EndInvoke(result[i]);
                    result[i].AsyncWaitHandle.Close();
                }

                maxVariance = variance[0];
                positionId  = 0;
                for (int i = 0; i < positionNo; i++)
                {
                    Console.WriteLine("variance[" + i + "]: " + variance[i]);
                    if (variance[i] > maxVariance)
                    {
                        maxVariance = variance[i];
                        positionId  = i;
                    }
                }
                if (mag_type == eMagType.MaxMag)
                {
                    _maxMagFocusPos = runPosition[positionId];
                }
                else
                {
                    _minMagFocusPos = runPosition[positionId];
                }
                _cur_mag      = mag_type;
                moveEventArgs = new MoveEventArgs('Z', runPosition[positionId], false);
                AsyncMove(this, moveEventArgs);
                AsyncMoveWait();
                _log.Debug("position id: " + positionId + ", position: " + runPosition[positionId] + ", variance: " + variance[positionId]);
                _log.Debug("Max AF func elapsed ms: " + maxAFFuncMs + ", Min AF func elapsed ms: " + minAFFuncMs);
                AutoLight(mag_type);
            }
            catch (Exception ex)
            {
                SynOpErrorArgs arg = new SynOpErrorArgs();
                arg.Ex      = ex;
                arg.Message = "SynOp.AutoFocus()";
                FindAngleOK = false;
                OnError(this, arg);
            }
        }