public TornituraSfacciatura()
: base()
{
Sgrossatura = new Operazione(this, LavorazioniEnumOperazioni.TornituraSfacciaturaSgrossatura);
Finitura = new Operazione(this, LavorazioniEnumOperazioni.TornituraSfacciaturaFinitura);
}
public Maschiatura(bool foroCentraleTornio)
: base(foroCentraleTornio)
{
MaschiaturaMaschioOp = new Operazione(this, LavorazioniEnumOperazioni.ForaturaMaschiaturaDx);
SensoMaschiatura = SensoMaschiatura.Dx;
}
//internal override Utensile CreateTool(LavorazioniEnumOperazioni enumOperationType)
//{
// var unit = Singleton.Instance.MeasureUnit;
// return FresaturaHelper.CreateTool((LavorazioniEnumOperazioni)enumOperationType, unit);
//}
//internal override List<Utensile> GetCompatibleTools(LavorazioniEnumOperazioni operationType, MagazzinoUtensile magazzino)
//{
// var unit = Singleton.Instance.MeasureUnit;
// return magazzino.GetTools<FresaCandela>(unit).Cast<Utensile>().ToList();
//}
protected override void CreateSpecificProgram(ProgramOperation programPhase, Operazione operazione)
{
// var fresa = operazione.Utensile as IDiametrable;
//var parametro = operazione.Utensile.ParametroUtensile as ParametroFresaCandela;
//if (fresa == null || parametro == null)
// throw new NullReferenceException();
//var diaFresa = fresa.Diametro;
//var larghezzaPassata = parametro.GetLarghezzaPassata();
//var profPassata = parametro.GetProfonditaPassata();
var moveCollection = new MoveActionCollection();
switch ((LavorazioniEnumOperazioni)operazione.OperationType)
{
default:
{
EngravingText(moveCollection, GetTextProfiles(), ProfonditaLavorazione, SicurezzaZ, InizioLavorazioneZ);
} break;
}
var mm = base.GetFinalProgram(moveCollection);
foreach (var variable in mm)
{
programPhase.AggiungiAzioneMovimento(variable);
}
}
internal override ProgramOperation GetOperationProgram(Operazione operazione)
{
/*
* - init program
* - toolChange ( poi in fase di calcolo programma vedo se saltarlo o meno )
* - settaggio feed. ( vedere meglio)
*
* -- calcolo programma ( questo è l'unica parte diversa )
*
* - rototraslazione operazioni
*/
var preference = Singleton.Preference.GetPreference(MeasureUnit);
var program = new ProgramOperation(0);
ExtraCorsa = preference.TurningSecureDistance;
//RapidSecureFeed = preference.TurningRapidSecureFeedSync;
var changeToolAction = new CambiaUtensileAction(program, operazione);
var rapidFeed = FaseDiLavoro.GetRapidFeed();
operazione.Utensile.ParametroUtensile.SetFeed(program, rapidFeed, 0, FeedType.Sync);
CreateSpecificProgram(program, operazione);
return(program);
}
public async Task <ActionResult> CreateOperazione(Operazione fm)
{
var u = await _userManager.GetUserAsync(HttpContext.User);
object operazione;
if (ModelState.IsValid)
{
if (fm.TipoOperazione == 0)
{
operazione = new MovimentoAvere(u.Id, fm.Cifra);
}
else
{
operazione = new MovimentoDare(u.Id, fm.Cifra);
}
_appdbcontext.Add(operazione);
await _appdbcontext.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
else
{
return(View(fm));
}
}
public Spianatura()
{
StartPoint = SquareShapeHelper.SquareShapeStartPoint.Center;
Sgrossatura = new Operazione(this, LavorazioniEnumOperazioni.FresaturaSpianaturaSgrossatura);
Finitura = new Operazione(this, LavorazioniEnumOperazioni.FresaturaSpianaturaFinitura);
}
private void btnProdotto_Click(object sender, EventArgs e)
{
//SECONDO METODO Istanzio il delegato
Operazione op = Prodotto;
//Richiamo
MessageBox.Show("Prodotto= " + op(10, 15));
}
public FresaturaLato()
{
Sgrossatura = new Operazione(this, LavorazioniEnumOperazioni.Sgrossatura);
Finitura = new Operazione(this, LavorazioniEnumOperazioni.Finitura);
Smussatura = new Operazione(this, LavorazioniEnumOperazioni.Smussatura);
}
private void btnSomma_Click(object sender, EventArgs e)
{
//PRIMO METODO per usare un delegate
//Istanzio il delegate e come parametro passo il nome della funzione
Operazione op = new Operazione(Somma); //Somma è la "funzione" puntata dal delegate
//Richiamo il delegate che eseguirà la funzione Somma
MessageBox.Show("Somma= " + op(10, 15));
}
public FresaturaFilettatura()
{
Pattern = PatternForatura.Circolare;
//Finitura = new Operazione(this, LavorazioniEnumOperazioni.Finitura);
//CentrinoForoApertura = new Operazione(this, (int)FresaturaEnumOperazioni.Centrino);
//ForaturaApertura = new Operazione(this, (int)FresaturaEnumOperazioni.Foratura);
FilettaturaOp = new Operazione(this, LavorazioniEnumOperazioni.FresaturaFilettare);
Smussatura = new Operazione(this, LavorazioniEnumOperazioni.Smussatura);
}
public FresaturaScanalaturaChiusa()
{
MillingPattern = EnumPatternMilling.PoligonoRegolare;
Sgrossatura = new Operazione(this, LavorazioniEnumOperazioni.Sgrossatura);
Finitura = new Operazione(this, LavorazioniEnumOperazioni.Finitura);
//CentrinoForoApertura = new Operazione(this, (int)FresaturaEnumOperazioni.Centrino);
//ForaturaApertura = new Operazione(this, (int)FresaturaEnumOperazioni.Foratura);
Smussatura = new Operazione(this, LavorazioniEnumOperazioni.Smussatura);
}
public TornituraScanalatura(GrooveDirection grooveDirection)
: base()
{
Sgrossatura = new Operazione(this, LavorazioniEnumOperazioni.TornituraScanalaturaSgrossatura);
Finitura = new Operazione(this, LavorazioniEnumOperazioni.TornituraScanalaturaFinitura);
NumeroGole = 1;
ScanalaturaType = grooveDirection;
}
public int dif(int a, int b, Operazione op)
{
if (a >= b)
{
return(op(a, b));
}
else
{
return(op(b, a));
}
}
/// <summary>
/// Metodo per ottenere miglior utensile fra quelli selezionati.
/// </summary>
/// <param name="operazione"></param>
/// <param name="utensiles"></param>
/// <param name="matGuid"></param>
/// <returns></returns>
public virtual Utensile PickBestTool(Operazione operazione, IEnumerable <Utensile> utensiles, Guid matGuid)
{
var tool = (from utensile in utensiles
from parametro in utensile.ParametriUtensile
where parametro.MaterialGuid == matGuid
orderby utensile.SaveTime descending
where utensile.OperazioneTipo == operazione.OperationType
select utensile).FirstOrDefault();
return(tool);
}
public TextEngravingModel()
{
AngleStart = -180;
AngleWidth = 180;
TextToEngrave = "Sample Text";
Smussatura = new Operazione(this, LavorazioniEnumOperazioni.Smussatura);
}
public void Intro()
{
Operazione[] ops = new Operazione[3];
ops[0] = Somma;
ops[1] = Sottrai;
ops[2] = Moltiplica;
var result = ops[2](50, 3);
// -- dictionary ----
Dictionary <TipoOperazione, Operazione> operazioni
= new Dictionary <TipoOperazione, Operazione>();
operazioni[TipoOperazione.Piu] = Somma;
operazioni[TipoOperazione.Meno] = Sottrai;
operazioni[TipoOperazione.Per] = Moltiplica;
var res = operazioni[TipoOperazione.Meno](20, 5);
int[] values = { 1, 2, 43, 6, 88, 2, 11 };
var res2 = ApplicaOperazioni(values, Moltiplica);
Trasformazione <string>[] trasformazioniStringhe =
{
Maiuscole, Minuscole, AggiungiChiocciola
};
Trasformazione <int>[] trasformazioniNumeriche =
{
Raddoppia, Quadrato
};
var resultNum = ApplicaTrasformazioni(5, trasformazioniNumeriche);
// Esercizio =>
//int[] risultati = ApplicaTrasformazioniSuArray(values, trasformazioniNumeriche);
}
protected override void CreateSpecificProgram(ProgramOperation programPhase, Operazione operazione)
{
var diametrable = operazione.Utensile as IDiametrable;
var parametro = operazione.Utensile.ParametroUtensile as ParametroFresaCandela;
if (diametrable == null)
{
return;
}
var diaFresa = diametrable.Diametro;
double profPassata = 0;
double larghezzaPassata = 0;
if (parametro != null)
{
profPassata = parametro.GetProfonditaPassata();
larghezzaPassata = parametro.GetLarghezzaPassata();
}
var moveCollection = new MoveActionCollection();
switch (operazione.OperationType)
{
case LavorazioniEnumOperazioni.Sgrossatura:
{
MillProgrammingHelper.FresaturaScanalaturaChiusaProgram(moveCollection, GetProfile(), ProfonditaLavorazione, Larghezza, SicurezzaZ, InizioLavorazioneZ, diaFresa, larghezzaPassata, profPassata, ExtraCorsa, SovrametalloFinituraProfilo, FinishWithCompensation);
} break;
case LavorazioniEnumOperazioni.Finitura:
{
MillProgrammingHelper.FresaturaScanalaturaChiusaProgram(moveCollection, GetProfile(), ProfonditaLavorazione, Larghezza, SicurezzaZ, InizioLavorazioneZ, diaFresa, larghezzaPassata, profPassata, ExtraCorsa, 0, FinishWithCompensation);
} break;
case LavorazioniEnumOperazioni.Smussatura:
{
FresaturaSmussaturaScanalaturaChiusaProgram(moveCollection, GetProfile(), ProfonditaLavorazione, SicurezzaZ, InizioLavorazioneZ, diaFresa, Larghezza);
} break;
}
var mm = base.GetFinalProgram(moveCollection);
foreach (var variable in mm)
{
programPhase.AggiungiAzioneMovimento(variable);
}
}
private void btnSottrazione_Click(object sender, EventArgs e)
{
/*
* Operazione op = Sottrazione;
*
* MessageBox.Show("Sottrazione= "+op(15,10));
*/
//3° metodo
//istanziamo il delegato
Operazione op = Sottrazione; //puntatore a sottrazione
//richiamo dif passandogli come parametro il delegato
MessageBox.Show("differenza = " + dif(10, 12, op).ToString());
}
public OperazioneViewModel(Operazione operazione, EditWorkViewModel parent)
: base(operazione.Descrizione, parent)
{
Operazione = operazione;
if (operazione.FirstStart)
{
AutoToolFind();
operazione.FirstStart = false;
}
else
{
LoadCompatibleTools();
}
}
public Alesatura(bool foraturaCentraleTornio)
: base(foraturaCentraleTornio)
{
DiametroForatura = 10;
ProfonditaForatura = 25;
SicurezzaZ = 2;
InizioZ = 0;
ProfonditaCentrino = 4;
ProfonditaSvasatura = 4;
AlesaturaOp = new Operazione(this, LavorazioniEnumOperazioni.ForaturaAlesatore);
}
protected override void CreateSpecificProgram(ProgramOperation programPhase, Operazione operazione)
{
var moveCollection = new MoveActionCollection();
var parametro = operazione.Utensile.ParametroUtensile as ParametroUtensileTornitura;
if (parametro == null)
{
return;
}
// La profondità di passata = x2
var profPassata = parametro.ProfonditaPassata * 2;
var preference = Singleton.Preference.GetPreference(Singleton.Instance.MeasureUnit);
var distacco = preference.DistaccoSgrossaturaTornitura;
var profile2D = Profile.GetProfileResult(false);
switch (operazione.OperationType)
{
case LavorazioniEnumOperazioni.TornituraSgrossatura:
{
TurnProgrammingHelper.GetRoughingTurnProgram(programPhase, moveCollection, profile2D, profPassata, ExtraCorsa, distacco, _tipoTornitura, UsaMacroSgrossatura, SovrametalloFinituraX, SovrametalloFinituraY);
}
break;
case LavorazioniEnumOperazioni.TornituraFinitura:
{
TurnProgrammingHelper.GetFinishingProgram(moveCollection, profile2D, _tipoTornitura, ExtraCorsa);
}
break;
default:
Trace.WriteLine("Tornitura.CreateSpecificProgram");
break;
}
foreach (var variable in moveCollection)
{
programPhase.AggiungiAzioneMovimento(variable);
}
}
protected DrillBaseClass(bool foraturaCentraleTornio)
{
ForaturaCentraleTornio = foraturaCentraleTornio;
if (ForaturaCentraleTornio)
{
Pattern = PatternForatura.TornioForaturaCentrale;
}
else
{
Pattern = PatternForatura.Circolare;
}
Centrinatura = new Operazione(this, LavorazioniEnumOperazioni.ForaturaCentrino);
Foratura = new Operazione(this, LavorazioniEnumOperazioni.ForaturaPunta);
Svasatura = new Operazione(this, LavorazioniEnumOperazioni.ForaturaSmusso);
}
public CambiaUtensileAction(ProgramOperation parent, Operazione operazione)
: base(parent)
{
// todo: gestire meglio secure z
SicurezzaZ = parent.SecureZ;
EtichettaUtensile = operazione.GetToolDescriptionName();
IsUtensileRotante = operazione.IsRotaryTool;
NumeroUtensile = operazione.GetToolPosition();
Velocità = operazione.GetSpeed();
Refrigerante = operazione.GetCoolant();
/*
* prendo sia numero postazioni che correttori centro di lavoro.
*/
CorrettoreUtensileTornio = operazione.GetLatheToolCorrector();
CorrettoreUtensileAltezzaCentro = operazione.GetToolHeightCorrector();
ModalitaVelocita = operazione.GetSpeedType();
RotazioneMandrino = operazione.SpindleRotation;
}
protected override void CreateSpecificProgram(ProgramOperation programPhase, Operazione operazione)
{
var moveCollection = new MoveActionCollection();
var zStart = InizioZ + Sovrametallo;
var parametro = operazione.Utensile.ParametroUtensile as ParametroUtensileTornitura;
if (parametro == null)
{
return;
}
var profPassata = parametro.ProfonditaPassata;
switch (operazione.OperationType)
{
case LavorazioniEnumOperazioni.TornituraSfacciaturaSgrossatura:
{
TurnProgrammingHelper.GetFaceRoughing(moveCollection, DiametroMax, DiametroMin, InizioZ, zStart, profPassata, 1);
}
break;
case LavorazioniEnumOperazioni.TornituraSfacciaturaFinitura:
{
TurnProgrammingHelper.GetFaceFinishing(moveCollection, DiametroMax, DiametroMin, InizioZ, 1);
}
break;
default:
Trace.WriteLine("Tornitura.CreateSpecificProgram");
break;
}
foreach (var action in moveCollection)
{
programPhase.AggiungiAzioneMovimento(action);
}
}
/// <summary>
/// Metodo utilizzato nella selezione automatica dell'utensile.
/// </summary>
/// <param name="operazione"></param>
/// <param name="utensiles"></param>
/// <param name="matGuid"></param>
/// <returns></returns>
public override Utensile PickBestTool(Operazione operazione, IEnumerable <Utensile> utensiles, Guid matGuid)
{
var d = GetDiameter(operazione.OperationType);
/* Fra utensili IDiameter */
var tool = (from utensile in utensiles
from parametro in utensile.ParametriUtensile
where parametro.MaterialGuid == matGuid
orderby utensile.SaveTime descending
//where utensile.OperazioneTipo == operazione.OperationType
select utensile);
var t = (from t1 in tool.OfType <IDiametrable>()
orderby Math.Abs(t1.Diametro - d)
select t1).FirstOrDefault();
if (t == null)
{
base.PickBestTool(operazione, utensiles, matGuid);
}
return(t as Utensile);
}
public Tornitura(TipoTornitura tipoTornitura)
: base()
{
_tipoTornitura = tipoTornitura;
Profile = new RawProfile(true);
/*
* per evitare danni inserisco punto iniziale qui,
* anche se e meglio che venga creato dentro ctorù */
var ini = new RawInitPoint2D(Profile);
Profile.Add(ini);
ini.X.SetValue(true, 0);
// AddDummyProfile(_tipoTornitura);
Sgrossatura = new Operazione(this, LavorazioniEnumOperazioni.TornituraSgrossatura);
Finitura = new Operazione(this, LavorazioniEnumOperazioni.TornituraFinitura);
}
public OperationMainScreenViewModel(Operazione operazione)
{
Operazione = operazione;
}
internal override ProgramOperation GetOperationProgram(Operazione operazione)
{
/*
* - init program
* - toolChange ( poi in fase di calcolo programma vedo se saltarlo o meno )
* - settaggio feed. ( vedere meglio)
*
* -- calcolo programma ( questo è l'unica parte diversa )
*
* - rototraslazione operazioni
*/
// todo : tenere conto anche dell'asse c attivazione g112 per il tornio ..
// Creo nuovo programma, tutte le lavorazioni ( hanno Z Sicurezza )
// anche perchè pensavo di settarla a livello di fase di lavoro..
var program = new ProgramOperation(SicurezzaZ);
// Se cambio utensile è opzionale , oppure se è forzato non cambio utensile..
//var cambioUtensile = (operazione.ToolChangeOptional && operazione.ForceToolChange) || !operazione.ToolChangeOptional;
var changeToolAction = new CambiaUtensileAction(program, operazione);
changeToolAction.CutViewerToolInfo = CutViewerHelper.PrintTool(operazione.Utensile);
// Ora setto avanzamenti comuni - Rapido - SecureFeed - Ecc..
// per ora setto cazzo .. dove lo posso prendere ??
var preference = Singleton.Preference.GetPreference(MeasureUnit);
ExtraCorsa = preference.MillEntryExitSecureDistance;
SecureFeed = preference.MillingRapidSecureFeedAsync;
/*
* L'idea per i feed e di cercare di inserirli tutti nel dizionario, se poi vengono usati ok,
* altrimenti è lo stesso..
*/
// Magari è piu corretto settarle nella classe base parametro..
var feed = operazione.Utensile.ParametroUtensile.GetFeed(FeedType.ASync);
var plungeFeed = operazione.Utensile.ParametroUtensile.GetPlungeFeed(FeedType.ASync);
/*
* Non controllo più che i feed siano <= 0 , al limite nel prog ci sarà scritto F0
*/
var rapidFeed = FaseDiLavoro.GetRapidFeed();
operazione.Utensile.ParametroUtensile.SetFeed(program, rapidFeed, SecureFeed, FeedType.ASync);
//var feedDictionary = new Dictionary<MoveType, double>
// {
// {MoveType.Rapid, 10000},
// {MoveType.SecureRapidFeed, SecureFeed},
// {MoveType.Work, feed},
// {MoveType.Cw, feed},
// {MoveType.Ccw, feed},
// {MoveType.PlungeFeed, plungeFeed},
// };
//program.SetFeedDictionary(feedDictionary);
/*
* ora c'è richiamo il metodo specifico della lavorazione.
* In ingresso prende il ProgramPhase. e Operazione.
*/
CreateSpecificProgram(program, operazione);
/*
* todo.
* qui andrebbe il metodo per fare le rototraslazioni.
* per ora lo lascio delegato alla lavorazione specifica
* per via del problemi con ciclo di foratura..
*/
return(program);
}
private void ExecuteControl(Operazione tipoOperazione)
{
if (UrlDaTestare.Count <= 0)
{
MessageBox.Show("Nessun URL selezionato");
return;
}
var lastFile = tipoOperazione == Operazione.ACCESSIBILITA ? Settings.Default.AccessFileName : Settings.Default.W3cFileName;
using (var dlg = new SaveFileDialog())
{
var lastDir = Settings.Default.LastDir;
dlg.InitialDirectory = lastDir;
dlg.Title = "Save result in ";
dlg.Filter = "txt files (*.txt)|*.txt|html files (*.html)|*.html";
var date = DateTime.Now;
//var name = string.Format("{0}_{1:dd-MM-yyyy_hh-mm-ss}.txt", Settings.Default.AccessFileName, date);
var name = string.Format("{0}.txt", lastFile, date);
dlg.FileName = name;
if (dlg.ShowDialog() == DialogResult.OK)
{
Settings.Default.LastDir = Path.GetDirectoryName(dlg.FileName);
//Settings.Default.AccessFileName = Path.GetFileNameWithoutExtension(dlg.FileName).Replace(string.Format("_{0:dd-MM-yyyy_hh-mm-ss}", date), "");
switch (tipoOperazione)
{
case Operazione.ACCESSIBILITA:
Settings.Default.AccessFileName = Path.GetFileNameWithoutExtension(dlg.FileName);
break;
case Operazione.VALIDAZIONE:
Settings.Default.W3cFileName = Path.GetFileNameWithoutExtension(dlg.FileName);
break;
default:
throw new Exception("Impossibile");
}
Settings.Default.Save();
if (File.Exists(dlg.FileName))
{
File.Delete(dlg.FileName);
}
InitBGWorkerStart();
//bgWorker do work
backgroundWorker1.RunWorkerAsync(new object[] { dlg.FileName, tipoOperazione });
}
}
}
/// 18/08/2011 /// <summary> /// Metodo V2 per creazione programma. /// Cerco di raggruppare ulteriormente metodi comuni per avere meno problemi. /// </summary> /// <returns></returns> internal abstract ProgramOperation GetOperationProgram(Operazione operazione);
/// <summary> /// Metodo astratto dove si genera la parte del programma specifica di ogni lavorazione. /// La parte in comune è stata raggruppata nel metodo GetOperationProgram. /// </summary> /// <param name="programPhase"></param> /// <param name="operazione"></param> protected abstract void CreateSpecificProgram(ProgramOperation programPhase, Operazione operazione);
