Beispiel #1
0
        //private bool _GeneratingLayer = false;
        //private bool _Stoped = false;//variable para DETENER la impresión

        //public bool Paused { get; private set; } = false;

        //private bool Stoped
        //{
        //    get
        //    {
        //        return _Stoped;
        //    }

        //    set
        //    {
        //        _Stoped = true;
        //        FrmCierre FrmC = new FrmCierre();

        //        FrmC.Show();
        //        FrmC.PGB.Visible = true;

        //        FrmC.Update();

        //        FrmC.PGB.Value = 20;
        //        Thread.Sleep(300);
        //        FrmC.PGB.Value = 40;
        //        Thread.Sleep(300);
        //        FrmC.PGB.Value = 60;
        //        Thread.Sleep(300);
        //        FrmC.PGB.Value = 80;
        //        Thread.Sleep(300);
        //        FrmC.PGB.Value = 100;
        //        Thread.Sleep(800);

        //        FrmC.Update();

        //        FrmC.Close();
        //    }
        //}


        public ModelSLT(/*ref System.IO.Ports.SerialPort serialPort*/)
        {
            /*_serialPort = serialPort;
             * _serialPort.DtrEnable = true;
             * _serialPort.ReceivedBytesThreshold = 1;
             * _serialPort.DataReceived += _Port_DataReceived;*/

            Solido = new SolidSLT();

            Solido.Changed += Solido_Changed;
            ZTrazado        = double.NaN;
            DeltaLayer      = 0.2;
            ZCalculo        = 0.0;

            _AnguloLayer = 0.0;

            LayerActual  = new StrokeSLT[0];
            LayerCalculo = new StrokeSLT[0];

            /*Printing = false;
             * Paused = false;
             * _Stoped = false;*/

            //_TImprimir = new Thread(new ThreadStart(_Trazar));
            //_TGenerarLayer = new Thread(new ThreadStart(_GeneraLayer));
        }
Beispiel #2
0
        /*public void Draw(bool isTest)
         * {
         *  _IsTest = isTest;
         *
         *  if (_TImprimir == null || !_TImprimir.IsAlive)
         *  {
         *      _TImprimir = new Thread(new ThreadStart(_Draw));
         *      _TImprimir.Start();
         *  }
         *  else
         *  {
         *      //avisa de que ya está en ejecución
         *      System.Windows.Forms.MessageBox.Show("Proceso de impresión ejecutándose.");
         *  }
         * }*/

        //bool IsTrazando = false;

        //private void _Draw()
        //{
        //StrokeSLT _Trazo = null;

        //Printing = true;

        //_AnguloLayer = 0.0;
        //ZCalculo = 0.0;

        ///*_TGenerarLayer = new Thread(new ThreadStart(_GeneraLayer));
        //_TGenerarLayer.Start();
        //_GenerandoLayer = true;*/

        //SendTemperature(160.0);

        //_GenerateLayer();

        ///*while(_GenerandoLayer )
        //{
        //    System.Threading.Thread.Sleep(500);
        //}*/

        //_ChangeLayer();

        ///*_TGenerarLayer = new Thread(new ThreadStart(_GeneraLayer));
        //_TGenerarLayer.Start();*/

        //_GenerateLayer();


        //if (ZCalculo <= Solido.Top)
        //{
        //    IsTrazando = true;

        //    _Trazo = new StrokeSLT();

        //    if (_LayerActual.Count() > 0)
        //    {
        //        _Trazo.Destino = _LayerActual[0].Destino;
        //    }
        //    else
        //    {
        //        _Trazo.Destino = new VertexSLT(0.0, 0.0, ZTrazado);
        //    }

        //    _Trazo.Mode = Modes.ModeTraslation;
        //    _Trazo.Pendiente = true;

        //    //Para calcular la distancia del trazado
        //    lastPoint = new Punto(_Trazo.Destino.X, _Trazo.Destino.Y, _Trazo.Destino.Z);

        //    //Envía el trazo
        //    SendStroke(_Trazo);



        //    while (IsTrazando)
        //    {
        //        /*_Trazo = NextStroke();//lo almacena en _trazo

        //        AnteriorTrazado = (_Trazo != null);

        //        //Envía los sucesivos trazos
        //        while(!_SendNextStroke)
        //        {
        //            //hace tiempo hasta que termina de enviar el comando
        //            Thread.Sleep(30);
        //        }

        //        if (SendStroke(ref _Trazo, AntDest.Distancia(new Punto(_Trazo.Destino.X, _Trazo.Destino.Y, AntDest.Z))))
        //        {
        //            AntDest = new Punto(_Trazo.Destino.X, _Trazo.Destino.Y, _Trazo.Destino.Z);
        //        }

        //        //_SendNBextStroke = false;*/

        //        if (Stoped)
        //        {
        //            if (_GeneratingLayer)
        //            {
        //                //_TGenerarLayer.Abort();
        //                _GeneratingLayer = false;
        //            }
        //            ZTrazado = double.NaN;
        //            break;
        //        }

        //        while (Paused)
        //        {
        //            System.Threading.Thread.Sleep(300);
        //        }

        //        System.Threading.Thread.Sleep(1000);
        //    }
        //}

        //SendTemperature();

        //ZTrazado = double.NaN;
        //Paused = false;
        //_Stoped = false;

        //// Fin del trazado
        //Printing = false;

        //// Presenta el trazado
        //StrokeSLT trzPresent = new StrokeSLT();
        //trzPresent.Destino = new VertexSLT(_Trazo.Destino.X, _Trazo.Destino.Y, _Trazo.Destino.Z + 50.0/*mm*/);
        //trzPresent.E = 0.0;
        //trzPresent.Mode = Modes.ModeTraslation;
        //trzPresent.Pendiente = true;
        //SendStroke(trzPresent);

        //trzPresent.Destino = new VertexSLT(0.0, 0.0, _Trazo.Destino.Z + 50.0);
        //trzPresent.E = 0.0;
        //trzPresent.Mode = Modes.ModeTraslation;
        //trzPresent.Pendiente = true;
        //SendStroke(trzPresent);
        //}

        /*public void PauseDraw()
         * {
         *  if (Printing)
         *  {
         *      Paused = true;
         *  }
         * }
         *
         * public void ResumeDraw()
         * {
         *  if (Printing)
         *  {
         *      Paused = false;
         *  }
         * }
         *
         * public void StopDraw()
         * {
         *  if (Printing)
         *  {
         *      Stoped = true;
         *      // _SendNextStroke = false;
         *  }
         * }*/

        internal void ChangeLayer()
        {
            LayerActual = new StrokeSLT[LayerCalculo.Count];

            for (int i = 0; i < LayerCalculo.Count; i++)
            {
                LayerActual[i] = LayerCalculo[i];
            }

            LayerCalculo = new List <StrokeSLT>();
        }
Beispiel #3
0
        public StrokeSLT FirstStroke()
        {
            StrokeSLT ResTrazo = new StrokeSLT();

            if (LayerActual.Length > 0)
            {
                ResTrazo.Destino = LayerActual[0].Destino;
            }
            else
            {
                ResTrazo.Destino = new VertexSLT(0.0, 0.0, ZTrazado);
            }

            ResTrazo.Mode      = Modes.ModeTraslation;
            ResTrazo.Pendiente = true;

            return(ResTrazo);
        }
Beispiel #4
0
        public StrokeSLT NextStroke()
        {
            StrokeSLT ResTrazo = null;

            // Only for cuit to next layer
            if (LayerActual.Length == 0)
            {
                ChangeLayer();

                GenerateLayer();

                ResTrazo           = new StrokeSLT();
                ResTrazo.Pendiente = true;
                ResTrazo.Mode      = Modes.ModeTraslation;
                ResTrazo.Destino   = new VertexSLT(0.0, 0.0, ZTrazado);
            }

            /*else
             * {
             *  ResTrazo = LayerActual[0];
             *  ResTrazo.Pendiente = true;
             *  ResTrazo.Mode = Modes.ModeTraslation;
             * }*/

            for (int i = 0; i < LayerActual.Length; i++)
            {
                if (LayerActual[i].Pendiente)
                {
                    LayerActual[i].Pendiente = false;

                    if (i == (LayerActual.Length - 1))
                    {
                        //Último trazo
                        StrokeSLT TempTrazo = new StrokeSLT();
                        TempTrazo.Pendiente = true;
                        TempTrazo.Mode      = Modes.ModeTraslation;
                        TempTrazo.Destino   = LayerActual[i].Destino;

                        /*while (_GenerandoLayer)
                         * {
                         *  System.Threading.Thread.Sleep(300);
                         * }*/

                        if (LayerCalculo == null)
                        {
                            //Ha terminado
                            ResTrazo = null;
                        }
                        else
                        {
                            //Carga y continúa con la siguiente capa
                            ChangeLayer();

                            TempTrazo.Destino = LayerActual[0].Destino;

                            GenerateLayer();

                            /*_TGenerarLayer = new Thread(new ThreadStart(_GeneraLayer));
                             * _TGenerarLayer.Start();*/
                        }
                        ResTrazo = TempTrazo;
                    }
                    else
                    {
                        //Siguiente trazo
                        ResTrazo = LayerActual[i + 1];
                    }
                    break;
                }
            }
            return(ResTrazo);
        }
Beispiel #5
0
        private IList <StrokeSLT> _GenerateFill(Poligonos Pols, double AnchoBoquilla, double Porcentaje, double AnguloTrama)
        {
            IList <StrokeSLT> Res = new List <StrokeSLT>();

            if (Porcentaje > 1.0)
            {
                Porcentaje = 1.0;
            }

            if (Porcentaje < 0.0)
            {
                Porcentaje = 0.0;
            }

            double PasoTrama = Porcentaje * AnchoBoquilla; // /1

            if (PasoTrama > 0.0)                           //omite PasoTrama inferior o igual a 0
            {
                //con el AnguloTrama y el PasoTrama intersectar con los poligonos
                //recorre el bounding box de los polígonos
                Punto  Centro       = Pols.Bownding.Centro;
                double SemiDiagonal = Pols.Bownding.Diagonal * 1.1 / 2.0;//con un 10% de margen

                double DeltaX = Convert.ToSingle(Math.Sin(Convert.ToDouble(AnguloTrama))) * SemiDiagonal;
                double DeltaY = Convert.ToSingle(Math.Sin((Math.PI / 2) - Convert.ToDouble(AnguloTrama))) * SemiDiagonal;

                //oriento el rayo
                Segmento Rayo = new Segmento(new Punto(Centro.X - DeltaX, Centro.Y - DeltaY, Centro.Z),
                                             new Punto(Centro.X + DeltaX, Centro.Y + DeltaY, Centro.Z));
                //desplazo al inicio
                Rayo = Rayo.Equidista(-SemiDiagonal);

                IList <Segmento> ResSegmentos = new List <Segmento>();

                bool InvierteTrazo = false;

                int Pasos = Convert.ToInt32(SemiDiagonal * 2.0 / PasoTrama);
                while (Pasos > 0)
                {
                    IList <Segmento> TempSegmentos = Pols.SegmentosInteriores(Rayo);

                    if (InvierteTrazo)
                    {
                        for (int i = TempSegmentos.Count - 1; i >= 0; i--)
                        {
                            StrokeSLT TT = new StrokeSLT();

                            //trazo de traslación
                            TT.Mode      = Modes.ModeTraslation;
                            TT.Pendiente = true;
                            TT.Destino   = new VertexSLT(TempSegmentos[i].Final.X, TempSegmentos[i].Final.Y, TempSegmentos[i].Final.Z);

                            Res.Add(TT);

                            //trazo de relleno
                            TT.Mode      = Modes.ModoFill;
                            TT.Pendiente = true;
                            TT.Destino   = new VertexSLT(TempSegmentos[i].Inicio.X, TempSegmentos[i].Inicio.Y, TempSegmentos[i].Inicio.Z);
                            //trazo de traslación
                            Res.Add(TT);
                        }
                    }
                    else
                    {
                        for (int i = 0; i < TempSegmentos.Count; i++)
                        {
                            StrokeSLT TT = new StrokeSLT();

                            //trazo de traslación
                            TT.Mode      = Modes.ModeTraslation;
                            TT.Pendiente = true;
                            TT.Destino   = new VertexSLT(TempSegmentos[i].Inicio.X, TempSegmentos[i].Inicio.Y, TempSegmentos[i].Inicio.Z);

                            Res.Add(TT);

                            //trazo de relleno
                            TT.Mode      = Modes.ModoFill;
                            TT.Pendiente = true;
                            TT.Destino   = new VertexSLT(TempSegmentos[i].Final.X, TempSegmentos[i].Final.Y, TempSegmentos[i].Final.Z);
                            //trazo de traslación
                            Res.Add(TT);
                        }
                    }

                    //a la próxima la dirección es la contraria
                    InvierteTrazo = !InvierteTrazo;

                    //desplaza PasoTrama el rayo y lo recalcula
                    Rayo = Rayo.Equidista(PasoTrama);

                    //evalua si se ha salido del bounding box
                    Pasos--;
                }
            }
            return(Res);
        }