// Use this for initialization
void Start()
{
plano = new Plano();
retasPlano = new Reta[2];
retasPlano[0] = new Reta(ObjsPontoPlano[0], ObjsPontoPlano[1]);
retasPlano[1] = new Reta(ObjsPontoPlano[0], ObjsPontoPlano[2]);
normal = new Reta();
normal = plano.CalcularN(retasPlano[0], retasPlano[1]);
vetorDirecaoReta = new Reta();
vetorDirecaoReta.x = Mathf.Round(ObjsPontoReta[1].transform.position.x) - (Mathf.Round(ObjsPontoReta[0].transform.position.x));
vetorDirecaoReta.y = Mathf.Round(ObjsPontoReta[1].transform.position.y) - (Mathf.Round(ObjsPontoReta[0].transform.position.y));
vetorDirecaoReta.z = Mathf.Round(ObjsPontoReta[1].transform.position.z) - (Mathf.Round(ObjsPontoReta[0].transform.position.z));
EquacaoParam = vetorDirecaoReta.EquacaoParametrica(ObjsPontoReta[0]);
stringTema.text = "Parametrica";
stringEquacaoParametrica.text = "";
foreach (var item in EquacaoParam)
{
stringEquacaoParametrica.text += item;
}
print("Reta Direção: " + Mathf.Round(vetorDirecaoReta.x) + ", " + vetorDirecaoReta.y + ", " + vetorDirecaoReta.z);
print("Normal: " + normal.x + ", " + normal.y + ", " + normal.z);
}
// GET: /Plano/PlanoCreate
public ActionResult PlanoCreate()
{
Plano plano = new Plano();
PlanoViewModel planoVM = new PlanoViewModel(plano);
return View(planoVM);
}
//public Assets.articulaciones_ articulaciones;
public Muslo(GameObject cadera, GameObject rodilla, Plano planosMovimiento, ArticulacionType articulacion)
{
this.cadera = cadera;
this.rodilla = rodilla;
this.planosMovimiento = planosMovimiento;
base.articulacion = articulacion;
Update();
}
public SegmentoPrimario(UnityEngine.GameObject puntoInterno, UnityEngine.GameObject puntoExterno, Plano planosMovimiento, Assets.ArticulacionType articulacion)
{
// TODO: Complete member initialization
this.hombro = puntoInterno;
this.codo = puntoExterno;
this.planosMovimiento = planosMovimiento;
base.articulacion = articulacion;
Update();
}
void Awake()
{
if (hips == null ||
spine == null ||
leftForeArm == null ||
leftFoot == null ||
leftHand == null ||
leftLeg == null ||
leftShoulder == null ||
leftArm == null ||
leftUpperLeg == null ||
rightForeArm == null ||
rightFoot == null ||
rightHand == null ||
rightLeg == null ||
rightShoulder == null ||
rightArm == null ||
rightUpperLeg == null
)
{
return;
}
planosMovimiento = new Plano(hips, rightShoulder, leftShoulder, spine);
segmentoCorporal.Add(new Visagra(leftUpperLeg, leftLeg, leftFoot, ArticulacionType.RodillaIzquierda));
segmentoCorporal.Add(new Visagra(rightUpperLeg, rightLeg, rightFoot, ArticulacionType.RodillaDerecha));
segmentoCorporal.Add(new Visagra(leftArm, leftForeArm, leftHand, ArticulacionType.CodoIzquierdo));
segmentoCorporal.Add(new Visagra(rightArm, rightForeArm, rightHand, ArticulacionType.CodoDerecho));
//TODO: Prueba
segmentoCorporal.Add(new Visagra(rightArm, leftArm, leftForeArm, ArticulacionType.HombroIzquierdo));
segmentoCorporal.Add(new Visagra(leftArm, rightArm, rightForeArm, ArticulacionType.HombroDerecho));
segmentoCorporal.Add(new SegmentoPrimario(rightArm, rightForeArm, planosMovimiento, ArticulacionType.BrazoDerecho));
segmentoCorporal.Add(new SegmentoSecundario(rightForeArm, rightHand, planosMovimiento, ArticulacionType.AnteBrazoDerecho));
segmentoCorporal.Add(new SegmentoPrimario(leftArm, leftForeArm, planosMovimiento, ArticulacionType.BrazoIzquierdo));
segmentoCorporal.Add(new SegmentoSecundario(leftForeArm, leftHand, planosMovimiento, ArticulacionType.AnteBrazoIzquierdo));
segmentoCorporal.Add(new SegmentoPrimario(rightUpperLeg, rightLeg, planosMovimiento, ArticulacionType.MusloDerecha));
segmentoCorporal.Add(new SegmentoSecundario(rightLeg, rightFoot, planosMovimiento, ArticulacionType.PiernaDerecha));
segmentoCorporal.Add(new SegmentoPrimario(leftUpperLeg, leftLeg, planosMovimiento, ArticulacionType.MusloIzquierda));
segmentoCorporal.Add(new SegmentoSecundario(leftLeg, leftFoot, planosMovimiento, ArticulacionType.PiernaIzquierda));
}
//altera os dados do aluno
public static bool AlterarPlano(Plano p)
{
try
{
ctx.Entry(p).State = System.Data.Entity.EntityState.Modified;
ctx.SaveChanges();
return(true);
}
catch (Exception)
{
return(false);
}
}
//remove cadastro do Plano
public static bool RemoverPlnao(Plano p)
{
try
{
ctx.Plano.Remove(p);
ctx.SaveChanges();
return(true);
}
catch (Exception)
{
return(false);
}
}
public static bool Incluir(Plano Plano)
{
try
{
entities.Planos.Add(Plano);
entities.SaveChanges();
return(true);
}
catch (Exception)
{
return(false);
}
}
public Plano ConsultePlanoDeSaude(string nome)
{
Plano plano = null;
_planos.ForEach(pln =>
{
if (pln.NomeDoPlano.Equals(nome))
{
plano = pln;
}
});
return(plano);
}
public void RetornaValorCorretoPrevisaoRendimentos(string mes, double esperado)
{
Plano plano = DadosBaseTestes.GeradorPlanoSimples();
List <ResumoFinanceiro> resumosFinanceiros = plano.PrevisaoRendimentos(10);
ResumoFinanceiro resumo = resumosFinanceiros
.FirstOrDefault(r => r.AnoMes == mes);
double valorAtual = Math.Round(resumo.ValorTotal, 2);
Assert.Equal(esperado, valorAtual);
}
public ActionResult Save(PlanoDto model)
{
if (ModelState.IsValid)
{
var Plano = new Plano();
_Plano.Save(model);
return(RedirectToAction("List"));
}
else
{
return(RedirectToAction("Create", model));
}
}
//Grids
protected void gridPlano_RowCommand(object sender, GridViewCommandEventArgs e)
{
if (e.CommandName.Equals("Editar"))
{
long id = Util.Geral.ObterDataKeyValDoGrid <long>(gridPlano, e, 0);
Plano p = OperadoraFacade.Instancia.CarregarPlano(id, Util.UsuarioLogado.IDContratante);
cboPlanoContratoAdm.SelectedValue = p.ContratoAdm.ID.ToString();
chkPlanoAtivo.Checked = p.Ativo;
txtPlanoDescicao.Text = p.Descricao;
chkPlanoQuartoColetivo.Checked = p.QuartoComum;
txtPlanoColetivoCodigo.Text = p.QuartoComumCodigo;
txtPlanoColetivoCodigoAns.Text = p.QuartoComumCodigoANS;
txtPlanoColetivoSubplano.Text = p.QuartoComumSubplano;
if (p.QuartoComumInicio.HasValue)
{
txtPlanoColetivoInicio.Text = p.QuartoComumInicio.Value.ToString("dd/MM/yyyy");
}
chkPlanoQuartoParticular.Checked = p.QuartoParticular;
txtPlanoParticularCodigo.Text = p.QuartoParticularCodigo;
txtPlanoParticularCodigoAns.Text = p.QuartoParticularCodigoANS;
txtPlanoParticularSubplano.Text = p.QuartoParticularSubplano;
if (p.QuartoParticularInicio.HasValue)
{
txtPlanoParticularInicio.Text = p.QuartoParticularInicio.Value.ToString("dd/MM/yyyy");
}
txtPlanoId.Text = p.ID.ToString();
this.planoSetaVisibilidadePaineis(true, false);
}
else if (e.CommandName.Equals("Excluir"))
{
long id = Util.Geral.ObterDataKeyValDoGrid <long>(gridPlano, e, 0);
try
{
OperadoraFacade.Instancia.ExcluirPlano(id);
this.carregarPlanos();
Util.Geral.Alerta(this, "Plano excluído com sucesso.");
}
catch
{
this.exibeModalPlanos("Não foi possível excluir o plano pois ele está sendo usado.");
}
}
}
public ActionResult Edit(Plano plano)
{
plano.Emissao = DateTime.Now;
if (ModelState.IsValid)
{
context.Entry(plano).State = EntityState.Modified;
context.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(plano));
}
public IHttpActionResult DeletePlano(int id)
{
Plano plano = db.Planos.Find(id);
if (plano == null)
{
return(NotFound());
}
db.Planos.Remove(plano);
db.SaveChanges();
return(Ok(plano));
}
public void Deletar(int idPlano)
{
var planos = new Plano()
{
Id = idPlano
};
using (var context = new CrudDbContext())
{
context.Remove(planos);
context.SaveChanges();
}
}
public void Alterar(Plano p)
{
AbrirConexao();
string query = "update Plano set Nome = @Nome, Descricao = @Descricao where IdPlano = @IdPlano";
cmd = new SqlCommand(query, con);
cmd.Parameters.AddWithValue("@IdPlano", p.IdPlano);
cmd.Parameters.AddWithValue("@Nome", p.Nome);
cmd.Parameters.AddWithValue("@Descricao", p.Descricao);
cmd.ExecuteNonQuery();
FecharConexao();
}
public IEnumerable <Plano> PlanoPorTipo(Plano parametro)
{
using (IDbConnection conexion = new SqlConnection("data source=SRV_APP_001\\MSSQLSERVER01;initial catalog=condominio;integrated security=false;user id=sa;password=R@bb1t20131992"))
//using (IDbConnection conexion = new SqlConnection("data source=GDPORLIM162\\PRUEBA;initial catalog=condominio;integrated security=false;user id=sa;password=pass"))
{
conexion.Open();
var parametros = new DynamicParameters();
parametros.Add("@p_idCatalogo", parametro.idCatalogo);
parametros.Add("@p_idTipoInmueble", parametro.idTipoInmueble);
var coleccion = conexion.Query <Plano>("dbo.Venta_Planos_pa", param: parametros, commandType: CommandType.StoredProcedure);
return(coleccion);
}
}
private void DataGridConsulta_MouseDoubleClick(object sender, MouseButtonEventArgs e)
{
if (dataGridConsulta.SelectedIndex >= 0)
{
Plano p = (Plano)dataGridConsulta.Items[dataGridConsulta.SelectedIndex];
textBoxCodigo.Text = p.codigo.ToString();
textBoxNomePlano.Text = p.nome;
textBoxRazaoSocial.Text = p.razao_social;
textBoxCNPJ.Text = p.cnpj;
textBoxANS.Text = p.registro_ans;
AlteraBotoes(3);
AlteraCampos(1);
}
}
public void InsertOrUpdate(Plano obj)
{
try
{
db.Entry(obj).State = obj.PlanoId == 0 ? EntityState.Added : EntityState.Modified;
db.SaveChanges();
db.Dispose();
}
catch (Exception ex)
{
throw new Exception("Error ao cadastrar Objeto!" + ex.Message);
}
}
public void Insert(Plano p)
{
OpenConnection();
string query = "insert into Plano(Nome, Descricao) " + "values(@Nome, @Descricao)";
cmd = new SqlCommand(query, con);
cmd.Parameters.AddWithValue("@Nome", p.Nome);
cmd.Parameters.AddWithValue("@Descricao", p.Descricao);
cmd.ExecuteNonQuery();
CloseConnection();
}
// GET: Planos/Delete/5
public ActionResult Delete(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Plano plano = db.Planos.Find(id);
if (plano == null)
{
return(HttpNotFound());
}
return(View(plano));
}
//PLANOS
/*********************************************************************************/
public Plano SalvarPlano(Plano plano)
{
using (ISession sessao = ObterSessao())
{
using (ITransaction tran = sessao.BeginTransaction())
{
plano.ContratoAdm = sessao.Get <ContratoADM>(plano.ContratoAdm.ID);
sessao.SaveOrUpdate(plano);
tran.Commit();
}
}
return(plano);
}
public void Register(PlanoViewModel PlanoViewModel)
{
var Plano = new Plano(
new Guid(),
PlanoViewModel.Nome,
PlanoViewModel.Minutos,
PlanoViewModel.FranquiaInternet,
PlanoViewModel.Valor,
PlanoViewModel.Tipo
);
_PlanoRepository.Add(Plano);
_PlanoRepository.SaveChanges();
}
public void Update(Plano p)
{
OpenConnection();
string query = "update Plano set Nome = @Nome, Descricao = @Descricao " + "where IdPlano = @IdPlano";
cmd = new SqlCommand(query, con);
cmd.Parameters.AddWithValue("@IdPlano", p.IdPlano);
cmd.Parameters.AddWithValue("@Nome", p.Nome);
cmd.Parameters.AddWithValue("@Descricao", p.Descricao);
cmd.ExecuteNonQuery();
CloseConnection();
}
// Update is called once per frame
void Update()
{
ChangeText();
plano = new Plano();
retasPlano = new Reta[2];
retasPlano[0] = new Reta(ObjsPontoPlano[0], ObjsPontoPlano[1]);
retasPlano[1] = new Reta(ObjsPontoPlano[0], ObjsPontoPlano[2]);
normal = new Reta();
normal = plano.CalcularN(retasPlano[0], retasPlano[1]);
vetorDirecaoReta = new Reta();
vetorDirecaoReta.x = Mathf.Round(ObjsPontoReta[1].transform.position.x) - (Mathf.Round(ObjsPontoReta[0].transform.position.x));
vetorDirecaoReta.y = Mathf.Round(ObjsPontoReta[1].transform.position.y) - (Mathf.Round(ObjsPontoReta[0].transform.position.y));
vetorDirecaoReta.z = Mathf.Round(ObjsPontoReta[1].transform.position.z) - (Mathf.Round(ObjsPontoReta[0].transform.position.z));
plano.EqGeral(ObjsPontoPlano[0]);
distancia.text = plano.Distancia(pontaFlecha).ToString();
if (Input.GetKeyDown(KeyCode.RightArrow))
{
switch (stringTema.text)
{
case "Eq. Geral Plano":
stringTema.text = "Parametrica";
stringEquacaoParametrica.text = "";
EquacaoParam = vetorDirecaoReta.EquacaoParametrica(ObjsPontoReta[1]);
foreach (var item in EquacaoParam)
{
stringEquacaoParametrica.text += item;
}
break;
case "Simetrica":
stringTema.text = "Eq. Geral Plano";
stringEquacaoParametrica.text = "asd";
stringEquacaoParametrica.text = plano.EqGeral(ObjsPontoPlano[0]);
print("n " + normal.x + "\n" + ObjsPontoReta[1].transform.position.x + "\n" + plano.x);
break;
case "Parametrica":
stringTema.text = "Simetrica";
stringEquacaoParametrica.text = vetorDirecaoReta.EquacaoSimetrica(ObjsPontoReta[1]);
break;
}
}
}
public List <Plano> Listar()
{
var registros = File.ReadAllLines(PATH);
foreach (var item in registros)
{
var valores = item.Split(";");
Plano plano = new Plano();
plano.Nome = valores[1];
plano.Preco = valores[2];
this.Planos.Add(plano);
}
return(this.Planos);
}
private void BtnExcluir_Click(object sender, RoutedEventArgs e)
{
Button button = sender as Button;
Plano plano = button.DataContext as Plano;
if (MessageBox.Show("Tem certeza que deseja excluir o plano " + plano.Nome + "?", "Exclusão de Plano", MessageBoxButton.YesNo, MessageBoxImage.Question) == MessageBoxResult.Yes)
{
PlanoDAO.RemovePlan(plano);
MessageBox.Show("Plano excluído com sucesso!");
}
else
{
MessageBox.Show("Operação Cancelada!");
}
}
public async Task <IActionResult> Create([Bind("PlanoID,TreinoID,DietaID,SemanaInicio,Selecionado,PlanoNome,Duracao,Completo")] Plano param)
{
if (ModelState.IsValid)
{
var user = await _userManager.GetUserAsync(HttpContext.User);
param.UserID = user.Id;
_context.Add(param);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(param));
}
public void DDDService_Add_Return_Be_Sucess()
{
var plano = new Plano
{
Id = 1,
Descricao = "Falemais 30",
TempoMinutos = 30,
CustoAdicionalMinuto = 10
};
_serviceMock.Add(plano);
_planoRepository.Verify(r => r.Add(
It.Is <Plano>(v => v.Descricao == plano.Descricao)));
}
public IActionResult Update(int id, [FromBody] Plano plano)
{
if (plano == null || plano.Id != id)
{
return(BadRequest());
}
if (!ModelState.IsValid)
{
return(BadRequest());
}
var _plano = _planoRepository.Find(id);
List <string> listDDD = new List <string>();
if (_plano == null)
{
return(NotFound("Plano não encontrado."));
}
//Assumindo que os dados de DDD, Operadora e tipo de plano já devem existir no BD
if (plano.PlanoDDD != null)
{
foreach (PlanoDDD item in plano.PlanoDDD)
{
listDDD.Add(item.CodigoDDD);
}
}
string validar_dados = DataValidate(plano.IdOperadora, plano.IdTipoPlano, listDDD);
if (string.IsNullOrEmpty(validar_dados))
{
_plano.Minutos = plano.Minutos;
_plano.Franquia = plano.Franquia;
_plano.UnidadeFranquia = plano.UnidadeFranquia;
_plano.Valor = plano.Valor;
_plano.IdTipoPlano = plano.IdTipoPlano;
_plano.IdOperadora = plano.IdOperadora;
_plano.PlanoDDD = plano.PlanoDDD;
_planoRepository.Update(_plano);
}
else
{
return(NotFound(validar_dados));
}
return(Ok(""));
}
public Cliente (int id,
string nome,
string endereco,
string email,
string fone,
string dataNascimento,
Plano plano)
{
this.id = 0;
this.nome = nome;
this.endereco = endereco;
this.email = email;
this.fone = fone;
this.dataNascimento = dataNascimento;
this.plano = plano;
}
private void BtnExcluirPlano_Click(object sender, RoutedEventArgs e)
{
if (dgMostraPlanos.SelectedIndex >= 0)
{
Plano p = (Plano)dgMostraPlanos.Items[dgMostraPlanos.SelectedIndex];
using (DBContexto ctx = new DBContexto())
{
p = ctx.Planos.Find(p.PlanoId);
ctx.Planos.Remove(p);
ctx.SaveChanges();
}
}
PreencherTabela();
}
public JsonResult Incluir(Plano plano)
{
var result = new ResultProcessing();
if (ModelState.IsValid)
{
result = servico.Salvar(plano);
if (result.Success)
{
return(Json(new { success = result.Success, message = result.Message }));
}
}
return(Json(new { success = false, message = "Error" }));
}
{/*
* CalcularContaCelular o valor da minha conta com base nos minutos para cada tipo de ligação,
* com base nos valores de cada tipo.
*
*/
static void Main(string[] args)
{
//Prototipação de código
var consumo = new Consumo("Arizio", 1, 2, 3);
var plano = new Plano("Smart", 0.10m, 0.35m, 0.75m, 30m);
var promocao = new DescontoSobreConsumo("Fale 30", 0.05m, 0.25m, 0.60m);
//plano.AdicionarPromocao(promocao);
var conta = plano.CalcularConta(consumo);
//decimal total = 0;
////Calculo do valor da conta Fixa
//Console.Write("ENTRE COM QUANTIDADE DE MINUTOS PARA FIXO: ");
//var qtdeMinutosFixo = int.Parse(Console.ReadLine());
//var valorContaFixa = Conta.CalculaValorFixo(qtdeMinutosFixo);
//total = valorContaFixa;
//Console.WriteLine("VALOR CONTA FIXA: " + valorContaFixa);
////Calculo do valor da conta Fixa
//Console.Write("ENTRE COM QUANTIDADE DE MINUTOS PARA CELULAR: ");
//var qtdeMinutosCelular = int.Parse(Console.ReadLine());
//var valorContaCelular = Conta.CalculaValorCelular(qtdeMinutosCelular);
//total = total + valorContaCelular;
//Console.WriteLine("VALOR CONTA CELULAR: " + valorContaCelular);
////Calculo do valor da conta Fixa
//Console.Write("ENTRE COM QUANTIDADE DE MINUTOS PARA INTERURBANO: ");
//var qtdeMinutosInter = int.Parse(Console.ReadLine());
//var valorContaInter = Conta.CalculaValorInterurbano(qtdeMinutosInter);
//total = total + valorContaInter;
//Console.WriteLine("VALOR CONTA INTERURBANO: " + valorContaInter);
//Console.WriteLine();
//Console.WriteLine("VALOR CONTA: " + total);
Console.ReadLine();
}
public IActionResult Post([FromForm] Plano item)
{
try
{
_planoApplication.Add(item);
return(new ObjectResult(item.Id));
}
catch (ArgumentNullException ex)
{
return(NotFound(ex));
}
catch (Exception ex)
{
return(BadRequest(ex));
}
}
public void Plano_Save_Changes_Is_Called()
{
var plano = new Plano
{
Id = 1,
Descricao = "Falemais 30",
TempoMinutos = 30,
CustoAdicionalMinuto = 10
};
_planoRepository.Add(plano);
var retorno = _planoRepository.GetById(1);
//Assert
Assert.NotNull(retorno);
Assert.IsAssignableFrom <Plano>(retorno);
}
public ActionResult PlanoCreateConfirmed(Plano plano)
{
try
{
plano = ObtemPlanoForm(plano, true);
if (ModelState.IsValid)
{
Plano planoExiste = new Plano();
planoExiste = null;
if (plano.STATUS == "A")
{
planoExiste = PlanoAtivaVigente(plano);
}
if (planoExiste == null || plano.STATUS == "I")
{
_planoAppService.Create(plano);
}
else
{
throw new InvalidOperationException("Já existe um perído vigente e ativo que coincide com a tentativa de inclusão / alteração");
}
return RedirectToAction("PlanoIndex");
}
}
catch (RetryLimitExceededException /* dex */)
{
//Log the error (uncomment dex variable name and add a line here to write a log.
ModelState.AddModelError("", "Erro ao salvar. Tente novamente ou, se o problema persistir, entre em contato com o suporte.");
}
return View(plano);
}
public ActionResult PlanoEditConfirmed(int? id)
{
if (id == null)
{
//return new HttpStatusCodeResult(HttpStatusCode.BadRequest);
throw new Exception();
}
var planoToUpdate = _planoAppService.Get(id ?? default(int));
planoToUpdate = ObtemPlanoForm(planoToUpdate);
if (ModelState.IsValid)
{
try
{
Plano planoExiste = new Plano();
planoExiste = null;
if (planoToUpdate.STATUS == "A")
{
planoExiste = PlanoAtivaVigente(planoToUpdate);
}
if (planoExiste == null || planoToUpdate.STATUS == "I")
{
_planoAppService.Update(planoToUpdate);
}
else
{
throw new InvalidOperationException("Já existe um perído vigente e ativo que coincide com a tentativa de inclusão / alteração");
}
return RedirectToAction("PlanoIndex");
}
catch (RetryLimitExceededException /* dex */)
{
//Log the error (uncomment dex variable name and add a line here to write a log.
ModelState.AddModelError("", "Erro na alteração. Tente novamente ou, se o problema persistir, entre em contato com o suporte.");
}
}
return View(planoToUpdate);
}
public override List<Plano> Projeta(BoundingVolume nCaixa)
{
List<Plano> Planos = new List<Plano>();
OBB Caixa2 = ((OBB)nCaixa);
// %--------------------------------------------------------
// % Projetando a Caixa2 nesta Caixa
// %--------------------------------------------------------
//pega os Vectores
Matrix t = Caixa2.VectoresFace.Clone();
//subtrai o centro para preparar para a rotação
t.SubtractInplace(this.Centro);
//rotaciona de acordo com a transformação estabelecida
t.MultiplyInplace(this.MatrixTransformacao);
//procurando distancias maximas e minimas a partir do centro projetado.
//centro projetado no SCL da caixa 1
//Vector Centro_Projetado = (Caixa2.Centro - Caixa1.Centro) * Caixa1.MatrixTransformação;
Vector Centro_Projetado = Caixa2.Centro.Clone();
Centro_Projetado.SubtractInplace(this.Centro);
Centro_Projetado.MatrixMultiplyInPlace(this.MatrixTransformacao);
//pega os VectoresFace da caixa 2 e subtrai o centro da caixa 2.
//desse modo os VetF estarao situados na origem
t.SubtractInplace(Vector.VectorRepetitionLines(Centro_Projetado, Caixa2.QntdVariaveis));
//Soma o valor absoluto em cada eixo (x, y, ....) pois existe uma combinação linear
//dos VetF que consegue atingir esse valor nesse eixo, configurando o máximo de extensão
//positivo ou negativo com esse módulo nesta direção.
t.Abs();
//Vector nt = t.SomaColuna();
Vector nt = Vector.Ones(t.ColumnCount);
nt.MatrixMultiplyInPlace(t);
Vector Maximo = Centro_Projetado.Add(nt);
Vector Minimo = Centro_Projetado.Subtract(nt);
// % Verifica se o centro projetado da caixa 2 no Vector 'i' da caixa 1 é
// % positivo ou negativo
for (int i = 0; i < Caixa2.QntdVariaveis; i++)
{
// % Se positivo, o menor valor das projecoes de todos os vertices
// % no Vector 'i' tem que ser maior que a borda da caixa
if (Centro_Projetado._data[i] > 0)
{
if (Minimo._data[i] > this.Limites._data[i])
{
Plano p = new Plano();
p.Minimo = Vector.Zeros(this.QntdVariaveis);
p.Minimo._data[i] = this.Limites._data[i];
// % PontoMin é o ponto pelo qual passa o plano mais rente a caixa
//p.Minimo = (p.Minimo * Caixa1.AutoVectores) + Caixa1.Centro;
p.Minimo.MatrixMultiplyInPlace(this.AutoVectores);
p.Minimo.AddInplace(this.Centro);
// % PontoMax é o ponto pelo qual passa o plano mais longe da caixa
p.Maximo = new Vector(this.QntdVariaveis);
p.Maximo._data[i] = Minimo._data[i];
//p.Maximo = (p.Maximo * Caixa1.AutoVectores) + Caixa1.Centro;
p.Maximo.MatrixMultiplyInPlace(this.AutoVectores);
p.Maximo.AddInplace(this.Centro);
double dummy = Math.Abs(Minimo._data[i] - this.Limites._data[i]);
// % Direção é o Vector normal ao plano de separação
p.VectorNormal = this.AutoVectores.GetRowVector(i);
p.Média = (p.Maximo.Add(p.Minimo));
p.Média.ScaleInplace(0.5);
p.bias = -(p.Média.ScalarMultiply(p.VectorNormal));
p.d_2 = Math.Max(dummy / 2, double.MinValue);
//p.significancia = 0;// p.d_2;// Caixa1.Qntd_Dados + Caixa2.Qntd_Dados;
Planos.Add(p);
break;
}
}
else if (Centro_Projetado._data[i] < 0)
{
// % Se negativo, o maior valor das projecoes de todos os vertices
// % no Vector 'i' tem que ser menor que a borda da caixa
if (Maximo._data[i] < -this.Limites._data[i])
{
Plano p = new Plano();
p.Minimo = new Vector(this.QntdVariaveis);
p.Minimo._data[i] = -this.Limites._data[i];
//p.Minimo = (p.Minimo * Caixa1.AutoVectores) + Caixa1.Centro;
p.Minimo.MatrixMultiplyInPlace(this.AutoVectores);
p.Minimo.AddInplace(this.Centro);
// % PontoMin é o ponto pelo qual passa o plano mais rente a caixa
p.Maximo = new Vector(this.QntdVariaveis);
p.Maximo._data[i] = Maximo._data[i];
//p.Maximo = (p.Maximo * Caixa1.AutoVectores) + Caixa1.Centro;
p.Maximo.MatrixMultiplyInPlace(this.AutoVectores);
p.Maximo.AddInplace(this.Centro);
double dummy = Math.Abs(Maximo._data[i] - this.Limites._data[i]);
// % PontoMin é o ponto pelo qual passa o plano mais longe da caixa
p.VectorNormal = this.AutoVectores.GetRowVector(i);
p.Média = p.Maximo.Add( p.Minimo);
p.Média.ScaleInplace(0.5);
p.bias = -(p.Média.ScalarMultiply(p.VectorNormal));
p.d_2 = Math.Max(dummy / 2, double.MinValue);
//p.significancia = 0;//p.d_2;// Caixa1.Qntd_Dados + Caixa2.Qntd_Dados;
Planos.Add(p);
break;
}
}
}
return Planos;
}
private double VerificaPonto(Vector Ponto, Plano Plano)
{
// % Verifica em qual plano o ponto esta
// % O plano divide o espaço em dois semi-espaços, um, que denominaremos
// % positivo, compreende o espaço acima do plano, ou seja, o que está
// % na direção apontada pelo Vector normal.
// % O segundo espaço é o negativo, por estar "abaixo" do plano seguindo
// % orientação oposta a do Vector normal.
// % Retorna +1 se esta acima do upper bound
// % Retorna -1 se esta abaixo do lower bound
// % A transicao e linear
// % A escolha de trabalhar com o intervalo de [-1,1] foi feita pois
// % existe na segunda camada de neuronios um peso denominado relevancia,
// % que indica quao "bom" e aquele plano. Dessa forma se ele classifica o
// % ponto como negativo ou positivo a influencia dessa multiplicacao deve
// % ser igual para ambas as classificacoes.
//if (UsaPtoMedio)
//{
// double d = (Plano.VectorNormal * (Ponto - (Plano.Maximo + Plano.Minimo) / 2).Transposto())[0, 0];
// if (d >= 0)
// {
// return 1;
// }
// else
// {
// return -1;
// }
//}
//else
//{
// double dmax = (Plano.VectorNormal * (Ponto - Plano.Maximo).Transposto())[0, 0];
// if (dmax >= 0)
// {
// return 1;
// }
// double dmin = (Plano.VectorNormal * (Ponto - Plano.Minimo).Transposto())[0, 0];
// if (dmin <= 0)
// {
// return -1;
// }
// else
// {
// return ((dmin / (dmax - dmin) * 2) + 1);
// }
//}
//######################################################
//#############Ultra fast calc##########################
//######################################################
double soma = 0;
for (int i = 0; i < Ponto.Length; i++) {
soma += Ponto._data [i] * Plano.VectorNormal._data [i];
}
//double soma = Ponto * Plano.VectorNormal;
soma += Plano.bias;
if (!tipo.Bounds) {
if (soma >= 0) {
return 1;
} else {
return -1;
}
} else {
soma /= Plano.d_2;
if (soma >= 1) {
return 1;
}
if (soma <= -1) {
return -1;
}
return soma;
}
}
public JointTypePlanoResult(ArticulacionType jt, Plano.planos p)
{
jointType = jt;
plain = p;
}
private Plano PlanoAtivaVigente(Plano pl)
{
return _planoAppService.Find(t => t.DESC_PLANO == pl.DESC_PLANO
&& t.STATUS == "A"
&& (
(t.DT_INI <= pl.DT_INI && t.DT_FIM >= pl.DT_INI)
|| (t.DT_FIM <= pl.DT_INI && t.DT_FIM >= pl.DT_FIM)
|| (pl.DT_INI <= t.DT_INI && pl.DT_FIM >= t.DT_FIM)
)
).FirstOrDefault();
}
private Plano ObtemPlanoForm(Plano pl, bool insert = false)
{
pl.DESC_PLANO = Request["Plano.DESC_PLANO"];
pl.DT_INI = Convert.ToDateTime(Request["Plano.DT_INI"]);
pl.DT_FIM = Convert.ToDateTime(Request["Plano.DT_FIM"]);
pl.STATUS = Request["Plano.STATUS"];
pl.LAST_MODIFY_DATE = DateTime.Now;
pl.LAST_MODIFY_USERNAME = _controleacessoAppService.ObtainCurrentLoginFromAd();
if (insert)
{
pl.CREATED_DATETIME = pl.LAST_MODIFY_DATE;
pl.CREATED_USERNAME = pl.LAST_MODIFY_USERNAME;
}
return pl;
}
//public Categoria Categoria { get; set; }
//public CategoriaPercentual CategoriaPercentual { get; set; }
//public PlanoCategoria PlanoCategoria { get; set; }
//public IEnumerable<SelectListItem> CategoriasSelectListItem { get; set; }
//public IEnumerable<SelectListItem> LojasSelectListItem { get; set; }
//public PlanoViewModel(Plano plano, IEnumerable<SelectListItem> categoriaSelectListItem, IEnumerable<SelectListItem> lojaSelectListItem)
//{
// Plano = plano;
// CategoriasSelectListItem = categoriaSelectListItem;
// LojasSelectListItem = lojaSelectListItem;
//}
public PlanoViewModel(Plano plano)
{
Plano = plano;
}
