Cuestionario 3 Parcial - Grupo3 Grafica

UNIVERSIDAD DE LAS FUERZAS ARMADAS
ESPE
SEDE LATACUNGA
CARRERA DE INGENIERÍA DE SOFTWARE
Cuestionario de la unidad III
Materia : Computación gráfica
Integrantes:
● Víctor Cuyo
● David Chango
● Ariel Gordillo
● Alison Velasteguí
Enero 2021
Objetivos
General
Desarrollar los ejercicios planteados en el cuestionario, mediante la utilización
de conocimiento adquirido previamente y fuentes de información confiables,
para poder entender de mejor manera la computación gráfica y todo lo que la
compone.
Específicos
- Investigar las fórmulas requeridas para poder resolver cada ejercicio
planteado.
- Analizar los enunciados planteados previamente y desarrollar los respectivos
aplicativos.
Análisis
En este cuestionario podremos observar preguntas que nos ayudarán a entender más sobre
temas como: gráficas por computadora en 2D utilizando diferentes modelos matemáticos, al
igual que la utilización de visual y C#, también conceptos básicos sobre la
lógica matemática dentro de la computación gráfica. Con este cuestionario podremos
aumentar nuestro conocimiento sobre la computación gráfica y sobre cómo funciona o como
se puede usar para la creación de figuras geométricas en 2D y 3D respectivamente.
Desarrollo
1. Qué es la línea oculta en computación gráfica
En computación gráfica, las líneas ocultas tienen varios usos, por ejemplo, permite ocultar la
parte de atrás de los objetos o bien los elementos que pasan por detrás de otros. Además, se
usa para mostrar superficies, bordes o esquinas de objetos que están ocultas a la vista, y
generalmente se representan por líneas segmentadas.

Dichas líneas ocultas sin duda es una de las partes más básicas y sumamente importantes dentro
de la computación gráfica.
Ejemplo:
2. Describa que es la prueba de visibilidad
Dentro de la computación gráfica existen varias técnicas las cuales son necesarias para poder
llevar a cabo un software de esta índole, siendo una de las principales causas las pruebas de
visibilidad al momento de realizarlo. Algoritmos simples que testean visibilidad (culling):
determinan las caras que no pueden verse desde el observador. Dichos algoritmos que son
utilizados para graficar o eliminar líneas, figuras, etc., dentro de computación gráfica, los
resultados deben someterse a alguno de los algoritmos mencionados a continuación. Por ej.
back-face culling, clipping del volumen de vista canónico. Esto garantiza la calidad de la
visualización para el usuario. Estos algoritmos muestrean el modelo y luego resuelven la
visibilidad. Por ej. raytracing o Z-buffer y los scan-line con buffers de profundidad.
3. Cuál es el objetivo de eliminar la línea oculta

La eliminación de las líneas ocultas de un objeto puede ser un proceso bastante costoso, por lo
tanto, esto nos obliga a aplicar sencillas comprobaciones para simplificar el problema todo lo
que podamos antes de realizar un estudio pormenorizado. Existe una comprobación muy
sencilla que eliminará la mayoría de las caras que no se pueden ver. Este test identifica las caras
que miran en la dirección opuesta al observador. Estas son las que constituyen la parte trasera
del objeto y no pueden verse porque la masa del objeto se encuentra entre ellas y el observador.
Esto, sin embargo, no resuelve la totalidad del problema de las superficies ocultas ya que es
posible que la parte delantera del objeto esté oculta por un segundo objeto o por cualquier otra
parte del mismo objeto. A pesar de ello, esta comprobación elimina aproximadamente la mitad
de las superficies que deben ser verificadas y por tanto simplifica el problema.
4. Que es un fractal y que características
Un fractal es un objeto geométrico en el que se repite el mismo patrón a diferentes escalas y
con diferente orientación.
Tienen varias características importantes, por ejemplo, Si un objeto fractal lo aumentamos,
los elementos que aparecen vuelven a tener el mismo aspecto independientemente de cuál sea
la escala que utilizamos, y formando parte, como en un mosaico de los elementos mayores.
Es decir, estos elementos tienen una estructura geométrica recursiva. Si observamos dos
fotografías de un objeto fractal con escalas diferentes (una en metros y otra en milímetros,
por ejemplo) sin nada que sirva de referencia para ver cuál es el tamaño, resultaría difícil
decir cuál es de las ampliaciones es mayor o si son distintas.
Los fractales desde su primera formulación tuvieron una vocación práctica de servir como
modelos para explicar la naturaleza. Fue el propio Benoit Mandelbrot quien tuvo el mérito de
intuir la potencia de los fractales para construir modelos que explicaran la realidad, desde un
inicio Mandelbrot, se dedicó al problema de medir la costa de Gran Bretaña usándolos.
Ejemplos de fractales en la vida cotidiana:
5. Dibuje un círculo inscrito en un triángulo, ingresando sus puntos
Para la siguiente actividad es necesario tener claro el modelo matemático que lleva dentro de
la lógica de programación de la misma.
Como primer punto, hay que ingresar los puntos tanto de A, B y C del triángulo que se va a
dibujar.
Posteriormente, para poder empezar con los cálculos, procedemos a sacar la distancia de los
puntos dados por el usuario tanto de A-B, A-C, B-C, de la siguiente manera:
Una vez aplicada la fórmula anterior, obtenemos la distancia de cada lado, la cual nos va a
servir para el siguiente cálculo que es el denominado semiperímetro, para ello, es necesario
aplicar la siguiente fórmula:
Una vez aplicada la fórmula, obtenemos como resultado el semiperímetro del triángulo en
cuestión, el cual es necesario para el siguiente cálculo, que es sacar el radio del círculo que va
a estar situado dentro del círculo, de la siguiente manera:
Donde hay que recalcar que a, b y c, son las distancias entre los puntos dados. Finalmente
calculamos el incentro del triángulo en cuestión, donde va a ser el punto céntrico del círculo
que se va a dibujar y la unión de las líneas del mismo. De la siguiente manera:
Una vez que ya tenemos todos los puntos y los cálculos correspondientes, el resultado de
manera general sería de la siguiente manera:

Implementación en código
Principalmente creamos una interfaz, la cual va a interactuar con el usuario, el ingreso de
datos y que va a mostrar los resultados gráficos:

Iniciamos con los datos miembros y todo lo necesario, como son los constructores y los
getters and setters:

Posteriormente se receptan los datos ingresados por el usuario, al igual que la función para
adquirir las coordenadas de los puntos y almacenamos los puntos previamente multiplicado
con el SF.
Una vez que ya tenemos listo todos nuestros datos, procedemos con los cálculos, como
primer punto, empezamos con la fórmula de la distancia, de la siguiente manera:
Posteriormente, Calculamos el Semiperímetro:

Inmediatamente, calculamos el radio del círculo inscrito dentro del triángulo:
Para terminar con los cálculos, procedemos a calcular el incentro, como se muestra en la
siguiente imagen:
Como siguiente punto, creamos la función para poder dibujar el triángulo, al igual que las
líneas que van a estar unidas al incentro:
Finalmente, creamos la función para poder dibujar el círculo dentro del triángulo, de la
siguiente manera:
Código completo
Clase
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
using System.Drawing.Drawing2D;
using System.Drawing;
namespace Ejercicio_5
class CEjercicio_5
//Datos Miembros
private float mX, mY;
private float mAX, mAY;
private float mBX, mBY;
private float mCX, mCY;

//Grafica
private Graphics mGraph;
private const float SF = 20;
private Pen mPen;
// Creamos getters y setters
public float X { get => mX; set => mX = value; }
public float Y { get => mY; set => mY = value; }
//Constructor
public CEjercicio_5()
mX = 0.0f; mY = 0.0f;
mAX = 0.0f; mAY = 0.0f;
mBX = 0.0f; mBY = 0.0f;
mCX = 0.0f; mCY = 0.0f;
// constructor con 2 parametrs
public CEjercicio_5(float x, float y)
mX = x;
mY = y;
}
// constructor con 1 parametrs
public CEjercicio_5(float x)
mX = x;
//los datos del objeto se asignan a los datos miembros
public CEjercicio_5(CEjercicio_5 V)
// asignar datos directo al miembro de clase desde el objeto
mX = V.mX;
mY = V.mY;
// Función que permite leer los tres lados del triángulo.
public void ReadData(NumericUpDown numAX,
NumericUpDown numAY,
NumericUpDown numBX,
NumericUpDown numBY,
NumericUpDown numCX,
NumericUpDown numCY)
try
{
mAX = (float)numAX.Value;
mAY = (float)numAY.Value;
mBX = (float)numBX.Value;
mBY = (float)numBY.Value;
mCX = (float)numCX.Value;
mCY = (float)numCY.Value;
catch
MessageBox.Show("Ingreso no válido...");
public CEjercicio_5 Triangle(float x, float y)
return (new CEjercicio_5(mX = x, mY = y));
public PointF VectortoPonitF(CEjercicio_5 V)
return new PointF(V.mX * SF, V.mY * SF);
//funcion que calcula la distancia

public CEjercicio_5 Distance(CEjercicio_5 U, CEjercicio_5 V)
return (new CEjercicio_5((float)Math.Sqrt((Math.Pow((V.mX - U.mX),2) +
Math.Pow((V.mY - U.mY),2)))));
//funcion que calcula el semiperímetro
public CEjercicio_5 Semiperimeter(CEjercicio_5 DAB, CEjercicio_5 DAC,
CEjercicio_5 DCB)
return (new CEjercicio_5((float)((DAB.mX + DAC.mX + DCB.mX) / 2)));
//funcion que calcula el radio
public CEjercicio_5 Radio(CEjercicio_5 S, CEjercicio_5 DAB, CEjercicio_5 DAC,
CEjercicio_5 DCB)
return new CEjercicio_5((float)Math.Sqrt(((S.mX - DAB.mX) * (S.mX - DAC.mX) *
(S.mX - DCB.mX)) / S.mX));
//Calculamos el incentro
public CEjercicio_5 Incenter(CEjercicio_5 A, CEjercicio_5 B, CEjercicio_5 C,
CEjercicio_5 DAB, CEjercicio_5 DAC, CEjercicio_5 DBC)
return (new CEjercicio_5(((A.mX * DBC.mX + B.mX * DAC.mX + C.mX *
DAB.mX) / (DAB.mX + DAC.mX + DBC.mX)), ((A.mY * DBC.mX + B.mY * DAC.mX +
C.mY * DAB.mX) / (DAB.mX + DAC.mX + DBC.mX))));
public void DrawLine(CEjercicio_5 V, Color color, PictureBox picCanvas)
mGraph = picCanvas.CreateGraphics();
mPen = new Pen(color, 3);
mPen.StartCap = LineCap.RoundAnchor;
mPen.EndCap = LineCap.RoundAnchor;
PointF origin = VectortoPonitF(this);
PointF end = VectortoPonitF(V);
//dibujo el vector
mGraph.DrawLine(mPen, origin, end);
//Dibuja el círculo
public void DrawCircle(CEjercicio_5 B, CEjercicio_5 R, Color, PictureBox picCanvas)
{
MessageBox.Show("Incentro en X: " + B.mX.ToString());
MessageBox.Show("Incentro en Y: " + B.mY.ToString());
mGraph.DrawEllipse(Pens.Blue, B.mX * SF - R.mX * SF, B.mY * SF - R.mX * SF,
R.mX * SF * 2, R.mX * SF * 2);
//salir de la aplicación
public void CloseForm(Form objform)
objform.Close();
Código de formulario
using System;
using System.ComponentModel;
using System.Data;
using System.Linq;
using System.Text;
namespace Ejercicio_5
public partial class Frm_Ejer_5 : Form
CEjercicio_5 ObjCEjer = new CEjercicio_5();
CEjercicio_5 PuntoA = new CEjercicio_5();
CEjercicio_5 PuntoB = new CEjercicio_5();
CEjercicio_5 PuntoC = new CEjercicio_5();
CEjercicio_5 DistanceAB = new CEjercicio_5();
CEjercicio_5 DistanceAC = new CEjercicio_5();
CEjercicio_5 DistanceBC = new CEjercicio_5();
CEjercicio_5 Semiperimeter = new CEjercicio_5();
CEjercicio_5 Radio = new CEjercicio_5();
CEjercicio_5 Incenter = new CEjercicio_5();
public Frm_Ejer_5()
InitializeComponent();
}
private void btnCalculate_Click(object sender, EventArgs e)
ObjCEjer.ReadData(numAX, numAY, numBX, numBY, numCX, numCY);
//asigno valores para graficar mi triangulo
PuntoA.Triangle((float)numAX.Value, (float)numAY.Value);
PuntoB.Triangle((float)numBX.Value, (float)numBY.Value);
PuntoC.Triangle((float)numCX.Value, (float)numCY.Value);
picCanvas.Refresh();
//dibujo el triangulo
PuntoA.DrawLine(PuntoB, Color.Black, picCanvas);
PuntoA.DrawLine(PuntoC, Color.Black, picCanvas);
PuntoB.DrawLine(PuntoC, Color.Black, picCanvas);
//calculo el Distancia
DistanceAB = DistanceAB.Distance(PuntoA, PuntoB);
DistanceAC = DistanceAB.Distance(PuntoA, PuntoC);
DistanceBC = DistanceAB.Distance(PuntoB, PuntoC);
//calcula en incentro
Incenter = Incenter.Incenter(PuntoA, PuntoB, PuntoC, DistanceAB, DistanceAC,
DistanceBC);
//calculo el semiperímetro
Semiperimeter = Semiperimeter.Semiperimeter(DistanceAB, DistanceAC,
DistanceBC);
//calculo el Radio
Radio = Radio.Radio(Semiperimeter, DistanceAB, DistanceAC, DistanceBC);
//grafico las medianas
PuntoA.DrawLine(Incenter, Color.Pink, picCanvas);
PuntoB.DrawLine(Incenter, Color.Pink, picCanvas);
PuntoC.DrawLine(Incenter, Color.Pink, picCanvas);
//grafico del circulo
Incenter.DrawCircle(Incenter, Radio, Color.Red, picCanvas);
private void button3_Click(object sender, EventArgs e)
ObjCEjer.CloseForm(this);
}
}
Prueba de la ejecución
6. Dibuje un círculo circunscrito en un triángulo, ingresando sus puntos
En geometría , el círculo circunscrito o circuncírculo de un polígono es un círculo que pasa por
todos los vértices del polígono. El centro de este círculo se llama circuncentro y su radio se
llama circunradio . No todos los polígonos tienen un círculo circunscrito. Un polígono que tiene
uno se llama polígono cíclico , o algunas veces polígono con cíclico porque sus vértices son
concíclicos . Todos los triángulos , todos los polígonos simples regulares , todos los rectángulos
, todos los trapecios isósceles y todas las cometas correctas son cíclicos.
Para este ejercicio se pretende dibujar un triángulo en el cual se ingresaron 3 puntos A, B y C
y con los datos poner encontrar las distancias de los segmentos generados, los puntos centrales
mediante las intersecciones de las mediatrices del triángulo y por último encontrar el radio del
círculo que se va a dibujar pasando por los puntos del triángulo.
Se espera conseguir lo siguiente
utilizando las siguientes fórmulas:
Se calcula la pendiente de las rectas ya que tenemos los puntos.

La fórmula del punto medio para comenzar a generar las mediatrices.
La pendiente de la recta mediatriz que pasa por r, por ser perpendicular al lado a, es la inversa
y de signo contrario a la pendiente de la recta hallada que contiene al lado a:
Sabiendo que la mediatriz Ma pasa por el punto medio y sabemos su pendiente, que es igual a
4, podemos obtener la ecuación de su recta.
Una vez conseguido se genera algo parecido a la siguiente figura:

Dando como resultado:

En la siguiente función se van a leer los datos que se necesita para dibujar el triangulo
Para el programa se decidió generar un plano cartesiano para que se pueda visualizar de una
manera más geométrica.

La siguiente función se dibuja el triángulo.
En la siguiente función prácticamente se realiza toda la lógica del programa
Funcionamiento
Código Fuente
Clase
using System;
using System.Text;
namespace Pregunta_6
class Pregunta6
// Datos Miembro
private float mid1x, mid1y, mid2x, mid2y, m1, m2, pcentrox, pcentroy;
private float mAx, mAy, mBx, mBy, mCx, mCy, AB, AC, CB, semiPer, radio, raiz;
private PointF mA, mB, mC;
private float SF = 20.0f;

//Get and Set
public float MAX { get => mAx; set => mAx = value; }
public float MBX { get => mBx; set => mBx = value; }
public float MCX { get => mCx; set => mCx = value; }
public float MAY { get => mAy; set => mAy = value; }
public float MBY { get => mBy; set => mBy = value; }
public float MCY { get => mCy; set => mCy = value; }
//constructor vacío
public Pregunta6()
// esta funcion lee los lados del triángulo y valida
public bool ReadData(NumericUpDown Ax, NumericUpDown Ay, NumericUpDown
Bx,
NumericUpDown By, NumericUpDown Cx, NumericUpDown Cy, PictureBox
picCanvas)
try
mA.X = (float)Ax.Value;
mA.Y = (float)Ay.Value;
mB.X = (float)Bx.Value;
mB.Y = (float)By.Value;
mC.X = (float)Cx.Value;
mC.Y = (float)Cy.Value;
return true;
catch (Exception e)
MessageBox.Show(e.Message);
return false;
// Dibuja el plano cartesiano
public void DrawAxis(PictureBox picCanvas)
mGraph.DrawLine(new Pen(Color.Red, 1), new Point(picCanvas.Width / 2, 0),
new Point(picCanvas.Width / 2, picCanvas.Height));
mGraph.DrawLine(new Pen(Color.Red, 1), new Point(0, picCanvas.Height / 2),
new Point(picCanvas.Width, picCanvas.Height / 2));
//Esta funcion dibuja el triangulo
public void DrawRectangle(PictureBox picCanvas)

{
mGraph.TranslateTransform(picCanvas.Width / 2, picCanvas.Height / 2);
mGraph.DrawLine(new Pen(Color.Black, 2), mA.X * SF, -mA.Y * SF, mB.X * SF, -
mB.Y * SF);//segmentoAB
mGraph.DrawLine(new Pen(Color.Black, 2), mB.X * SF, -mB.Y * SF, mC.X * SF, -
mC.Y * SF);//segmento BC
mGraph.DrawLine(new Pen(Color.Black, 2), mC.X * SF, -mC.Y * SF, mA.X * SF, -
mA.Y * SF);//segmento CA
//Esfuncion calcula la mediatriz, el punto medio de la inteccion de las mediatrices y grafica
el circuncentro
public bool dibujar(PictureBox picCanvas)
mGraph.TranslateTransform(picCanvas.Width / 2, picCanvas.Height / 2);
AB = (float)Math.Sqrt(Math.Pow((mB.X - mA.X), 2) + Math.Pow((mB.Y - mA.Y),
2));// segmento AB -a
CB = (float)Math.Sqrt(Math.Pow((mB.X - mC.X), 2) + Math.Pow((mB.Y - mC.Y),
2));// SegmentoCB - b
AC = (float)Math.Sqrt(Math.Pow((mC.X - mA.X), 2) + Math.Pow((mC.Y - mA.Y),
2));// Segmetno AC -C
//Calculo de los puntos de la mediatriz en el Segmento BC

mid1x = (mB.X + mC.X) / 2;
mid1y = (mB.Y + mC.Y) / 2;
//Calculo de la pendiente entre el punto de BC
m1 = (mC.Y - mB.Y) / (mC.X - mB.X);
//Calculo de los puntos de la mediatriz en el Segmento AC
mid2x = (mA.X + mC.X) / 2;
mid2y = (mA.Y + mC.Y) / 2;
//Calculo de la pendiente entre el punto de AC
m2 = (mA.Y - mC.Y) / (mA.X - mC.X);
//cálculo de las coordenadas de los puntos centrales mediante de intersección entre las
dos rectas
pcentrox = ((mid2x / m2) - (mid1x / m1) + mid2y - mid1y) / ((1 / m2) + (-1 / m1));
pcentroy = -(-1 / m1) * (pcentrox - mid1x) + mid1y;
//mostramos los puntos centrales
MessageBox.Show("centro x=" + pcentrox + "\n centro y=" + pcentroy);
//Se calcula el semiperímetro para encontrar el radio del circulo
semiPer = (AB + CB + AC) / 2;
//se calcula las operaciones intermedias de la formula del radio
raiz = (float)Math.Sqrt((semiPer - CB) * (semiPer - AB) * (semiPer - AC) * semiPer);
radio = (AB * CB * AC) / (4 * raiz);
//Se grafica el circulo de forma antihoraria
for (double i = 0.00; i < 10; i += 0.001)
float coordX = (float)(radio * SF * Math.Sin(i));

float coordy = (float)(radio * SF * Math.Cos(i));
mGraph.DrawRectangle(new Pen(Color.Green, 2), pcentrox * SF + coordX,
pcentroy * SF + coordy, 1, 1);
return true;
Form
using System;
using System.Data;
using System.Linq;
using System.Text;
namespace Pregunta_6
public partial class Form1 : Form
Pregunta6 obj = new Pregunta6();
public Form1()
{
private void numCY_ValueChanged(object sender, EventArgs e)
if (obj.ReadData(numAX, numAY, numBX, numBY, numCX, numCY, picCanvas))
// if inputs are valid the axis will be draw
obj.DrawAxis(picCanvas);
obj.DrawRectangle(picCanvas);
if (obj.dibujar(picCanvas))
button1.Enabled = true;
{
picCanvas.CreateGraphics().Clear(Color.White);
7. Dibuje un círculo inscrito en un triángulo, seleccionando los 3 puntos con el mouse
Con el mismo principio del ejercicio 5 anteriormente explicado, se procede a recopilar
nuevamente la explicación y formulas a utilizar tengo del presente problema, con la única
variante, de que los puntos van a ser seleccionados por el usuario con la utilización del mouse,
de la siguiente manera:
Como primer punto, hay que ingresar los puntos tanto de A, B y C del triángulo que se va a
dibujar. Con la utilización del mouse
Posteriormente, para poder empezar con los cálculos, procedemos a sacar la distancia de los
puntos dados por el usuario tanto de A-B, A-C, B-C, de la siguiente manera:
Una vez aplicada la fórmula anterior, obtenemos la distancia de cada lado, la cual nos va a
servir para el siguiente cálculo que es el denominado semiperímetro, para ello, es necesario
aplicar la siguiente fórmula:

Una vez aplicada la fórmula, obtenemos como resultado el semiperímetro del triángulo en
cuestión, el cual es necesario para el siguiente cálculo, que es sacar el radio del círculo que va
a estar situado dentro del círculo, de la siguiente manera:
Donde hay que recalcar que a, b y c, son las distancias entre los puntos dados. Finalmente
calculamos el incentro del triángulo en cuestión, donde va a ser el punto céntrico del círculo
que se va a dibujar y la unión de las líneas del mismo. De la siguiente manera:
Una vez que ya tenemos todos los puntos y los cálculos correspondientes, el resultado de
manera general sería de la siguiente manera:


Posteriormente se receptan los datos ingresados por el usuario, al igual que la función para
adquirir las coordenadas de los puntos y almacenamos los puntos previamente multiplicado
con el SF. Aquí se presenta la única variante que se diferencia con el ejercicio 5
Una vez que ya tenemos listo todos nuestros datos, procedemos con los cálculos, como
primer punto, empezamos con la fórmula de la distancia, de la siguiente manera:
Posteriormente, Calculamos el Semiperímetro:
Inmediatamente, calculamos el radio del círculo inscrito dentro del triángulo:

Para terminar con los cálculos, procedemos a calcular el incentro, como se muestra en la
siguiente imagen:
Como siguiente punto, creamos la función para poder dibujar el triángulo, al igual que las
líneas que van a estar unidas al incentro:
Finalmente, creamos la función para poder dibujar el círculo dentro del triángulo, de la
siguiente manera:
Dentro del formulario, es necesario tener la función para el ingreso con el mouse:
Código completo
Clase
using System;
using System.Linq;
using System.Text;
namespace Ejercicio7
class CEjercicio_7
// Datos miembro
// Grafica
private Pen mPen;
// Creamos getter y setters
// Constructor
public CEjercicio_7()
mX = 0.0f; mY = 0.0f;
mAX = 0.0f; mAY = 0.0f;
mBX = 0.0f; mBY = 0.0f;
mCX = 0.0f; mCY = 0.0f;
// Constructor con dos parámetros
public CEjercicio_7(float x, float y)

{
mX = x;
mY = y;
// constructor con un parámetro
public CEjercicio_7(CEjercicio_7 v)
mX = v.mX;
mY = v.mY;
public CEjercicio_7(float x)
mX = x;
// Funcion para leer los datos de entrada
public void ReadData(List<Point> points)
try
mAX = (float)points[0].X;
mAY = (float)points[0].Y;
mBX = (float)points[1].X;
mBY = (float)points[1].Y;
mCX = (float)points[2].X;
mCY = (float)points[2].Y;
catch (Exception e)
public CEjercicio_7 Triangle(float x, float y)
return (new CEjercicio_7(mX = x, mY = y));
public PointF VectortoPonitF(CEjercicio_7 v)
return (new PointF(v.mX * SF, v.mY * SF));
// Funcion que calcula la distancia
public CEjercicio_7 Distance(CEjercicio_7 U, CEjercicio_7 V)
{
return (new CEjercicio_7((float)Math.Sqrt((Math.Pow((V.mX - U.mX), 2) +
Math.Pow((V.mY - U.mY), 2)))));
//funcion que calcula el semiperímetro
public CEjercicio_7 Semiperimeter(CEjercicio_7 DAB, CEjercicio_7 DAC,
CEjercicio_7 DCB)
return (new CEjercicio_7((float)((DAB.mX + DAC.mX + DCB.mX) / 2)));
//funcion que calcula el radio
public CEjercicio_7 Radio(CEjercicio_7 S, CEjercicio_7 DAB, CEjercicio_7 DAC,
CEjercicio_7 DCB)
return new CEjercicio_7((float)Math.Sqrt(((S.mX - DAB.mX) * (S.mX - DAC.mX) *
(S.mX - DCB.mX)) / S.mX));
//Calculamos el incentro
public CEjercicio_7 Incenter(CEjercicio_7 A, CEjercicio_7 B, CEjercicio_7 C,
CEjercicio_7 DAB, CEjercicio_7 DAC, CEjercicio_7 DBC)
{
return (new CEjercicio_7(((A.mX * DBC.mX + B.mX * DAC.mX + C.mX *
DAB.mX) / (DAB.mX + DAC.mX + DBC.mX)), ((A.mY * DBC.mX + B.mY * DAC.mX +
C.mY * DAB.mX) / (DAB.mX + DAC.mX + DBC.mX))));
public void DrawLine(CEjercicio_7 V, Color color, PictureBox picCanvas)
//dibujo el vector
//Dibuja el círculo
public void DrawCircle(CEjercicio_7 B, CEjercicio_7 R, Color color, PictureBox
picCanvas)
MessageBox.Show("Incentro en X: " + B.mX.ToString());
MessageBox.Show("Incentro en Y: " + B.mY.ToString());
mGraph.DrawEllipse(Pens.Blue, B.mX * SF - R.mX * SF, B.mY * SF - R.mX * SF,
R.mX * SF * 2, R.mX * SF * 2);
//salir de la aplicación
public void CloseForm(Form objform)
objform.Close();
Código dentro del formulario
using System;
using System.Data;
using System.Linq;
using System.Text;
CEjercicio_7 ObjCEjer = new CEjercicio_7();
CEjercicio_7 PuntoA = new CEjercicio_7();
CEjercicio_7 PuntoB = new CEjercicio_7();
CEjercicio_7 PuntoC = new CEjercicio_7();
CEjercicio_7 DistanceAB = new CEjercicio_7();
CEjercicio_7 DistanceAC = new CEjercicio_7();
CEjercicio_7 DistanceBC = new CEjercicio_7();
CEjercicio_7 Semiperimeter = new CEjercicio_7();
CEjercicio_7 Radio = new CEjercicio_7();
CEjercicio_7 Incenter = new CEjercicio_7();
List<Point> points = new List<Point>();
public Form1()
private void onClick(object sender, MouseEventArgs e)

{
if (points.Count < 3)
MessageBox.Show("X en: "+e.Location.X / 20 + " Y en: "+e.Location.Y / 20);
points.Add(
new Point(e.Location.X/20, e.Location.Y/20)
);
if(points.Count == 3)
else
MessageBox.Show("Ya se han ingresado los tres puntos del triángulo");
ObjCEjer.ReadData(points);

PuntoA.Triangle((float)points[0].X, (float)points[0].Y);
PuntoB.Triangle((float)points[1].X, (float)points[1].Y);
PuntoC.Triangle((float)points[2].X, (float)points[2].Y);
//calcula en incentro
Incenter = Incenter.Incenter(PuntoA, PuntoB, PuntoC, DistanceAB, DistanceAC,
DistanceBC);
//calculo el semiperímetro
Semiperimeter = Semiperimeter.Semiperimeter(DistanceAB, DistanceAC,
DistanceBC);
//calculo el Radio
Radio = Radio.Radio(Semiperimeter, DistanceAB, DistanceAC, DistanceBC);
//grafico las medianas
PuntoA.DrawLine(Incenter, Color.Pink, picCanvas);
PuntoB.DrawLine(Incenter, Color.Pink, picCanvas);
PuntoC.DrawLine(Incenter, Color.Pink, picCanvas);
//grafico del circulo
Incenter.DrawCircle(Incenter, Radio, Color.Red, picCanvas);
points.Clear();
Prueba de ejecución
8. Dibuje un círculo circunscrito en un triángulo, seleccionando los 3 puntos con el mouse
En geometría , el círculo circunscrito o circuncírculo de un polígono es un círculo que pasa por
todos los vértices del polígono. El centro de este círculo se llama circuncentro y su radio se
llama circunradio . No todos los polígonos tienen un círculo circunscrito. Un polígono que tiene
uno se llama polígono cíclico , o algunas veces polígono con cíclico porque sus vértices son
concíclicos . Todos los triángulos , todos los polígonos simples regulares , todos los rectángulos
, todos los trapecios isósceles y todas las cometas correctas son cíclicos.
Para este ejercicio se pretende dibujar un triángulo en el cual se ingresaron 3 puntos A, B y C
y con los datos poner encontrar las distancias de los segmentos generados, los puntos centrales
mediante las intersecciones de las mediatrices del triángulo y por último encontrar el radio del
círculo que se va a dibujar pasando por los puntos del triángulo.
Se espera conseguir lo siguiente
utilizando las siguientes fórmulas:
Se calcula la pendiente de las rectas ya que tenemos los puntos.

La fórmula del punto medio para comenzar a generar las mediatrices.
La pendiente de la recta mediatriz que pasa por r, por ser perpendicular al lado a, es la inversa
y de signo contrario a la pendiente de la recta hallada que contiene al lado a:
Sabiendo que la mediatriz Ma pasa por el punto medio y sabemos su pendiente, que es igual a
4, podemos obtener la ecuación de su recta.
Una vez conseguido se genera algo parecido a la siguiente figura:

Dando como resultado:

Se crea las variables miembros y los getters and setters
Se inicializan las variables y se leen los puntos que van a ser seleccionados en la pantalla por
el mouse.
Se calcula la distancia de los segmentos generados.
Posteriormente se calcula la pendiente invertida y las mediatrices de los segmentos.

Se aplica la misma lógica matemática del ejercicio 6, pero esta vez enviando como parámetro
la misma clase.
Finalmente se dibujan las líneas enviando como parámetro los puntos, esto nos sirve para
generar el triángulo.
En la clase del formulario se generan las variables para enviar los parámetros a la función.
Se utiliza la función onClick para poder guardar los puntos que el usuario ingresa dando clic
en la pantalla.
Finalmente se pasan todos los parámetros a las funciones creadas esto en el botón dibujar.
Funcionamiento
Código fuente
Clase
using System;
using System.Linq;
using System.Text;
class Pregunta_8
{
// Datos miembro
private float a, b, c, radio, semiPer, s1, calx, caly;
// Grafica
private Pen mPen;
// Creamos getter y setters
// Constructor
public Pregunta_8()
mX = 0.0f; mY = 0.0f;
mAX = 0.0f; mAY = 0.0f;
mBX = 0.0f; mBY = 0.0f;
mCX = 0.0f; mCY = 0.0f;

}
// Constructor con dos parámetros
public Pregunta_8(float x, float y)
mX = x;
mY = y;
// constructor con un parámetro
public Pregunta_8(Pregunta_8 v)
mX = v.mX;
mY = v.mY;
public Pregunta_8(float x)
mX = x;
// Funcion para leer los datos de entrada
public void ReadData(List<Point> points)
{
try
mAX = (float)points[0].X;
mAY = (float)points[0].Y;
mBX = (float)points[1].X;
mBY = (float)points[1].Y;
mCX = (float)points[2].X;
mCY = (float)points[2].Y;
catch (Exception e)
public Pregunta_8 Triangle(float x, float y)
return (new Pregunta_8(mX = x, mY = y));
public PointF VectortoPonitF(Pregunta_8 v)
return (new PointF(v.mX * SF, v.mY * SF));
}
// Funcion que calcula la distancia de los segmentos
public Pregunta_8 Distance(Pregunta_8 U, Pregunta_8 V)
return (new Pregunta_8((float)Math.Sqrt((Math.Pow((V.mX - U.mX), 2) +
Math.Pow((V.mY - U.mY), 2)))));
//FUNCION QUE CALCULA LA PENDIENTE INVERTIDDA
public float pendienteNeg(Pregunta_8 U, Pregunta_8 V)
return (-(V.mX - U.mX) / (V.mY - U.mY));
public Pregunta_8 Median(Pregunta_8 V)
return (new Pregunta_8((mX + V.mX) / 2, (mY + V.mY) / 2));
//FUNCION QUE CALCULA EL CIRCUNCENTRO
public void Circumcenter(Pregunta_8 A, Pregunta_8 B, Pregunta_8 C, Pregunta_8 Med1,
Pregunta_8 Med2, PictureBox picCanvas)
float Pac = pendienteNeg(A, C);
float Pbc = pendienteNeg(B, C);

a = (float)Math.Sqrt(Math.Pow(C.mX - B.mX, 2) + Math.Pow(C.mY - B.mY, 2));
b = (float)Math.Sqrt(Math.Pow(A.mX - C.mX, 2) + Math.Pow(A.mY - C.mY, 2));
c = (float)Math.Sqrt(Math.Pow(A.mX - B.mX, 2) + Math.Pow(A.mY - B.mY, 2));
//Se calcula el semiperimetro para encontrar el radio del circulo
semiPer = (a + b + c) / 2;
//se calcula las operaciones intermedias de la formula del radio
radio = (float)(a * b * c / (4 * Math.Sqrt(semiPer * (semiPer - a) * (semiPer - b) *
(semiPer - c))));
//cálculo de las coordenadas de los puntos centrales mediante de intersección entre las
dos rectas
mX = (Pac * Med2.mX - Med2.mY - Pbc * Med1.mX + Med1.mY) / (Pac - Pbc);
mY = Pac * (mX - Med2.mX) + Med2.mY;
MessageBox.Show("centro x=" + mX + "\n centro y=" + mY);
for (double i = 0.0; i < 10; i += 0.001)
calx = (float)(radio * SF * Math.Sin(i));
caly = (float)(radio * SF * Math.Cos(i));
mGraph.DrawRectangle(new Pen(Color.Green, 2), calx + mX * SF, caly + mY * SF,
1, 1);
}
}
public void DrawLine(Pregunta_8 V, Color color, PictureBox picCanvas)
//dibujo el vector
Form
using System;
using System.Data;
using System.Linq;
using System.Text;
Pregunta_8 ObjCEjer = new Pregunta_8();
Pregunta_8 PuntoA = new Pregunta_8();
Pregunta_8 PuntoB = new Pregunta_8();
Pregunta_8 PuntoC = new Pregunta_8();
Pregunta_8 MedA = new Pregunta_8();
Pregunta_8 MedB = new Pregunta_8();
Pregunta_8 MedC = new Pregunta_8();
Pregunta_8 DistanceAB = new Pregunta_8();
Pregunta_8 DistanceAC = new Pregunta_8();
Pregunta_8 DistanceBC = new Pregunta_8();
List<Point> points = new List<Point>();
Pregunta_8 Circumcenter = new Pregunta_8();
public Form1()
}
private void onClick(object sender, MouseEventArgs e)
if (points.Count < 3)
MessageBox.Show("X en: " + e.Location.X / 20 + " Y en: " + e.Location.Y / 20);
points.Add(
new Point(e.Location.X / 20, e.Location.Y / 20)
);
if (points.Count == 3)
else
MessageBox.Show("Ya se han ingresado los tres puntos del triángulo");
ObjCEjer.ReadData(points);
PuntoA.Triangle((float)points[0].X, (float)points[0].Y);
PuntoB.Triangle((float)points[1].X, (float)points[1].Y);
PuntoC.Triangle((float)points[2].X, (float)points[2].Y);
//Calculo de las medianas
MedA = PuntoB.Median(PuntoC);
MedB = PuntoA.Median(PuntoC);
MedC = PuntoA.Median(PuntoB);

Circumcenter.Circumcenter(PuntoA, PuntoB, PuntoC, MedA, MedB, picCanvas);
points.Clear();
9. Lea 3 lados del triángulo y dibuja el círculo de 9 punto
Para resolver el presente ejercicio se pide que el usuario ingrese los lados del triángulo,
entonces el proceso que se debe seguir es el siguiente:
1.- Se representa un segmento de medida igual al primer lado ingresado.
2.- Desde cada extremo del primer lado se traza una circunferencia de radio el valor del
segundo y tercer lado.
3.- El triángulo tiene por vértices los extremos del primer segmento y una de las
intersecciones de las circunferencias.
Es importante tener en cuenta que para realizar la construcción la medida de cada lado ha de
ser menor que la suma de los otros dos.
Conociendo el algoritmo para la construcción del triángulo, ahora debemos crear un modelo
matemático que nos permita hacerlo, La primera coordenada de nuestro triangulo la vamos a
ubicar en el origen, por lo tanto, será A(0,0), el segundo vértice tendrá como coordenadas en
X la distancia del primer lado y en Y será 0, por lo tanto, será B(lado1, 0).
Para la tercera coordenada debemos calcular los puntos de intersección entre las dos
circunferencias.
La fórmula de la circunferencia es:
Restando las fórmulas de cada circunferencia:
Al despejar la formula y reemplazar los datos tenemos las coordenadas de intersección tanto
en x como en y:
Para dibujar los puntos del circulo, se necesita el centro que será el vértice C del triángulo y el
radio que es la longitud de un lado y el modelo matemático que se uso es el siguiente:
Una vez listo el modelo matemático se procede a implementar el código, primero vamos a crear
una interfaz que va a tener 3 NumericUpDown que permitirán el ingreso de cada lado del
triángulo, cuenta con dos Butons el uno que dibujara el triángulo con los puntos del circulo y
otro que permita limpiar los datos y la pantalla, y por último tenemos un PictureBox donde se
dibujarán los gráficos.

La interfaz se ve así:
A continuación, se creará la clase Ctriangle la cual tiene la funcion ReadData donde vamos a
leer los datos ingresados por teclado

En la funcion plotGraphic es donde se usará la intersección de las circunferencias para dibujar
el triangulo
Y en la funcion DrawCircle es donde vamos a dibujar los puntos del circulo

El programa en ejecución se ve de la siguiente forma
El Código de la clase CTriangle

class CTriangle
//Datos miembros
private float mS1, mS2, mS3, mArea, mPerimeter, mSemiPerimeter;
private Graphics mGrap; //Definir la variable para el control del grafico
private const int SF = 20; //Scale Factor
private Pen mPen;//Activar la pluma para dibujar el lienzo o picture
private Point[] mPnts = new Point[3];
private int xt, yt;
//Funciones miembro
//Funcion constructor
//nos permite inicializar la clase según los datos que tenemos
public CTriangle()
mS1 = 0.0f;
mS2 = 0.0f;
mS3 = 0.0f;
mArea = 0.0f;
mPerimeter = 0.0f;
mSemiPerimeter = 0.0f;
mPnts[0] = new Point(0, 0);
//Funcion para leer datos
public bool ReadData(NumericUpDown numS1, NumericUpDown numS2,
NumericUpDown numS3)
try
mS1 = float.Parse(numS1.Text);
if ((mS1 + mS2) > mS3 && (mS1 + mS3) > mS2 && (mS2 + mS3) > mS1)
{
return (true);
else
MessageBox.Show("No es un triangulo", "Revisalo");
return (false);
catch
MessageBox.Show("Ingreso de incorrecto de algún lado");
return (false);
//Inicializar datos
public void inicializeData(NumericUpDown numS1, NumericUpDown numS2,
NumericUpDown numS3, PictureBox picCanvas)
numS1.Value = 0;
numS2.Value = 0;
numS3.Value = 0;
numS1.Focus();
mS1 = 0.0f;
mS2 = 0.0f;
mS3 = 0.0f;
//Funcion de graficacion
public void plotGraphics(PictureBox picCanvas)
mGrap = picCanvas.CreateGraphics();//Activa funciones para graphics
mPen = new Pen(Color.Aqua, 3);
//Traslada los puntos al origen
mGrap.TranslateTransform(picCanvas.Width / 2, picCanvas.Height / 2);
mGrap.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.AntiAlias;
//Calcula el punto de intersección entre dos circunferencias para hallar el punto C del
triángulo
xt = ((int)Math.Pow(mS2, 2) - (int)Math.Pow(mS3, 2) + (int)Math.Pow(mS1, 2)) / (2 *
(int)mS1);
yt = (int)Math.Sqrt(Math.Pow(mS2, 2) - Math.Pow(xt, 2));
mPnts[1] = new Point((int)mS1 * SF, 0);
mPnts[2] = new Point(xt * SF, yt * SF);
mGrap.DrawPolygon(mPen, mPnts);
MessageBox.Show("xt" + xt*SF + "\nyt" + yt*SF);
}
public void arc(PictureBox picCanvas)
mGrap = picCanvas.CreateGraphics();
mPen = new Pen(Color.Black, 2);
int x = 0;
int y = (int)mS2*10;
int e = 0, u = 1;
int v = 2 * (int)mS2*10 - 1;
while (x <= y)
mGrap.DrawRectangle(mPen, xt*SF + x, yt*SF + y, 2, 2);
mGrap.DrawRectangle(mPen, xt*SF + y, yt*SF - x, 2, 2);

mGrap.DrawRectangle(mPen, xt*SF - x, yt*SF - y, 2, 2);
mGrap.DrawRectangle(mPen, xt*SF - y, yt*SF + x, 2, 2);
mGrap.DrawRectangle(mPen, xt*SF + y, yt*SF + x, 2, 2);
mGrap.DrawRectangle(mPen, xt*SF + x, yt*SF - y, 2, 2);
mGrap.DrawRectangle(mPen, xt*SF - y, yt*SF - x, 2, 2);
mGrap.DrawRectangle(mPen, xt*SF - x, yt*SF + y, 2, 2);
x++;
e += u;
u += 2;
if (v < 2 * e) { y--; e -= v; v -= 2; }
public void DrawCircle( PictureBox picCanvas)
mGrap = picCanvas.CreateGraphics();

int x = 0, y = (int)mS2*10, u = 1, e = 0;
int v = 2 * (int)mS2*10 - 1;
while (x < y)
mGrap.DrawRectangle(mPen, xt*SF + y, yt*SF - x, 2, 2);
mGrap.DrawRectangle(mPen, xt*SF - x, yt*SF - y, 2, 2);
mGrap.DrawRectangle(mPen, xt*SF - y, yt*SF + x, 2, 2);
x++; e += u; u += 2;
if (v < 2 * e) { y--; e -= v; v -= 2; }
if (x < y) break;
mGrap.DrawRectangle(mPen, xt*SF + y, yt*SF + x, 2, 2);
mGrap.DrawRectangle(mPen, xt*SF + x, yt*SF - y, 2, 2);
mGrap.DrawRectangle(mPen, xt*SF - y, yt*SF - x, 2, 2);
mGrap.DrawRectangle(mPen, xt*SF - x, yt*SF + y, 2, 2);

}
public void ExitForm(Form objform)
objform.Close();
10. Grafique una escalera en 3D y luego represente en formato alambre
Para dibujar la escalera en 3D se le pide al usuario que ingrese el ancho, el largo y el alto de la
escalera, el modelo matemático que se uso fue simple. Primero se estableció las coordenadas
de la cara superior e inferior del primer escalón con los datos que se ingresaron y luego en cada
escalón se va restando 10 centímetros del largo original, esto sería nuestra coordenada x, y en
la coordenada y vamos aumentando el alto que se ingresó en cada escalón y en la coordenada
z puede variar entre 0 y el ancho ingresado.
Se creo una interfaz que contiene 3 NumericUpDown para ingresar los datos de la escalera, 3
Button el uno dibuja la escalera en 3D, el segundo dibuja la escalera en formato alambre, el
tercero limpia la pantalla y por último un PictureBox donde se dibujara los datos.
Se creo una clase llamada CLader la cual tiene una funcion readData que permite leer los datos
ingresados por teclado y almacenarlos en variables.
La funcion Convertir2D almacena las coordenadas 3D de x, y, z y las transforma en
coordenadas 2D
En la funcion DrawLine3D es donde vamos a dibujar la escalera, y crearemos un ciclo for que
ira alterando los valores de las coordenadas de cada escalón
El programa en ejecución se ve de la siguiente manera:
● Modo 3D
● Modo Alambre
● Ambos
El código de la clase CLader
using System;
using System.Linq;
using System.Text;
namespace ejercicio10
class CLader
{
//Datos miembro
private int mAX, mAZ, mH;
private int ang = 125;//ángulo del plano
//activar el control grafico
Pen mPen;
//propiedades
public int AX { get; set; }
public int H { get; set; }
public int AZ { get; set; }
//constructor vacío
public CLader()
mAX = 0;
mH = 0;
mAZ = 0;
//constructor inicializando
public CLader(int X, int Y, int Z)
mAX = X;
mH = Y;
mAZ = Z;
//Leer Datos
public void readData(NumericUpDown numAX,
NumericUpDown numAZ, NumericUpDown numH)
mAX = (int)numAX.Value;
mAZ = (int)numAZ.Value;
mH = (int)numH.Value;
//Convertir a coordenadas 2D
private Point Convertir2D(int X, int Y, int Z)
//crear un punto
Point p = new Point();
//convertir de 3D a 2D
p.X = (int)(Z * Math.Cos(ang * Math.PI / 180)) + X;
p.Y = (int)(Z * Math.Sin(ang * Math.PI / 180)) + Y;
return p;
//Convertir a Coordenadas 2D retornando un punto

public Point convertir2D(int X, int Y, int Z)
return new Point
X = (int)(Z * Math.Cos(ang * Math.PI / 180)) + X,
Y = (int)(Z * Math.Sin(ang * Math.PI / 180)) + Y
};
//Dibujar la escalera
public void drawLine3D(PictureBox pic_graph, bool op)
mGraph = pic_graph.CreateGraphics();
mGraph.TranslateTransform(pic_graph.Width / 2, pic_graph.Height / 2);
mGraph.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.AntiAlias;
//Puntos iniciales
int x=0, y=0, z=0;
//Lista de puntos
var pointsBotton = new PointF[4];
var pointsTop = new PointF[4];
var pointsLeft = new PointF[4];
var pointsRight = new PointF[4];
var pointsFront = new PointF[4];

//Botton
pointsBotton[0] = Convertir2D(x,y,z);
pointsBotton[1] = Convertir2D(x,y,mAZ);
pointsBotton[2] = Convertir2D(mAX,y,mAZ);
pointsBotton[3] = Convertir2D(mAX,y,z);
//Top
pointsTop[0] = Convertir2D(x, -mH, z);
pointsTop[1] = Convertir2D(x, -mH, mAZ);
pointsTop[2] = Convertir2D(mAX, -mH, mAZ);
pointsTop[3] = Convertir2D(mAX, -mH, z);
//Left
pointsLeft[0] = pointsBotton[1];
pointsLeft[2] = pointsTop[2];
//Right
pointsRight[0] = pointsBotton[0];
pointsRight[2] = pointsTop[3];
//Front
pointsFront[0] = pointsBotton[2];
pointsFront[2] = pointsTop[3];
if (op == true)
//Figura 3D
mGraph.FillPolygon(Brushes.LightGray, pointsBotton);
mGraph.FillPolygon(Brushes.Gray, pointsTop);
mGraph.FillPolygon(Brushes.Gray, pointsLeft);
mGraph.FillPolygon(Brushes.Gray, pointsRight);
mGraph.FillPolygon(Brushes.Gray, pointsFront);
else
//Modo alambre
mGraph.DrawPolygon(Pens.Black, pointsBotton);
mGraph.DrawPolygon(Pens.Black, pointsTop);
mGraph.DrawPolygon(Pens.Black, pointsLeft);
mGraph.DrawPolygon(Pens.Black, pointsRight);
mGraph.DrawPolygon(Pens.Black, pointsFront);
}
//Declarar contadores
int auxHS = -mH;
int auxHM = -mH*2;
int auxAX = mAX-20;
//Resto de bases y top
for (int a = 0; a < 8; a++)
//Botton
pointsBotton[0] = Convertir2D(x, auxHS, z);
pointsBotton[1] = Convertir2D(x, auxHS, mAZ);
pointsBotton[2] = Convertir2D(auxAX, auxHS, mAZ);
pointsBotton[3] = Convertir2D(auxAX, auxHS, z);
//Top
pointsTop[0] = Convertir2D(x, auxHM, z);
pointsTop[1] = Convertir2D(x, auxHM, mAZ);
pointsTop[2] = Convertir2D(auxAX, auxHM, mAZ);
pointsTop[3] = Convertir2D(auxAX, auxHM, z);
//Left
//Right
//Front
if (op)
//Modo 3D
mGraph.FillPolygon(Brushes.Gray, pointsBotton);
mGraph.FillPolygon(Brushes.LightGray, pointsTop);
mGraph.FillPolygon(Brushes.Gray, pointsLeft);
mGraph.FillPolygon(Brushes.Gray, pointsRight);
mGraph.FillPolygon(Brushes.LightGray, pointsFront);
else
//Modo alambre
mGraph.DrawPolygon(Pens.Black, pointsBotton);
mGraph.DrawPolygon(Pens.Black, pointsTop);
mGraph.DrawPolygon(Pens.Black, pointsLeft);
mGraph.DrawPolygon(Pens.Black, pointsRight);
mGraph.DrawPolygon(Pens.Black, pointsFront);
//Contadores de variables auxiliares
auxAX -= 10;
auxHM -= mH;
auxHS -= mH;
Conclusiones
- Se ha logrado de una forma óptima la implementación de los distintos modelos
matemáticos, lo cual ayuda a un mejor rendimiento en los diferentes ejercicios
realizados, también se ha concluido que la aplicación de algoritmos y modelos
matemáticos ayuda a que la implementación de código sea más sencilla y limpia.
Recomendaciones
- Cada ejercicio propuesto tiene su grado de dificultad, pero es importante conocer bien
las funciones de cada lenguaje de programación.
- Se recomienda investigar la documentación del lenguaje de programación para poder
utilizar de una manera más optima todas las herramientas y facultades que este lenguaje
nos ofrece.
Glosario:
- Visual Studio: es un entorno de desarrollo integrado para Windows y macOS. Es
compatible con múltiples lenguajes de programación, tales como C++, C#, Visual Basic
- C#: es un lenguaje de programación multiparadigma desarrollado y estandarizado por
la empresa Microsoft como parte de su plataforma .
- Algoritmo: Conjunto ordenado de operaciones sistemáticas que permite hacer un
cálculo
y hallar la solución de un tipo de problemas.
- Modelo matemático: Representación matemática de un proceso.
Bibliografía
Acerca de las líneas ocultas y la disciplina de vista. (2019, agosto 13). AutoDesk.
https://knowledge.autodesk.com/es/support/revit-products/learn-
explore/caas/CloudHelp/cloudhelp/2019/ESP/Revit-DocumentPresent/files/GUID-
E39CB6DD-7A32-4A91-95D6-E1E30FD0DD5E-htm.html
OCULTAMIENTO DE LÍNEAS Y SUPERFICIES. (2019, Julio 09). Expresión gráfica.
http://www.mieres.uniovi.es/egi/dao/apuntes/ocultamiento.html
Rasemary, T. B. (2012, diciembre 01). Renderizado. Graficación por computador.
https://sites.google.com/site/grafcomputacional/animacion-3d/renderizado
Legalización de los participantes
Nombres Apellidos CC Firma

Ariel Santiago Gordillo Lucas 0504442914
Víctor Hugo Cuyo Chiluisa 0504426362
David Bernardo Chango 1804726113

Caisabanda
Alison Karina Velasteguí Asto 1718856808

Cuestionario 3 Parcial - Grupo3 Grafica

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Cuestionario 3 Parcial - Grupo3 Grafica

Cargado por

Copyright:

Formatos disponibles

UNIVERSIDAD DE LAS FUERZAS ARMADAS

Cuestionario de la unidad III

Materia : Computación gráfica

Desarrollar los ejercicios planteados en el cuestionario, mediante la utilización

de conocimiento adquirido previamente y fuentes de información confiables,

para poder entender de mejor manera la computación gráfica y todo lo que la

- Investigar las fórmulas requeridas para poder resolver cada ejercicio

- Analizar los enunciados planteados previamente y desarrollar los respectivos

temas como: gráficas por computadora en 2D utilizando diferentes modelos matemáticos, al

igual que la utilización de visual y C#, también conceptos básicos sobre la

lógica matemática dentro de la computación gráfica. Con este cuestionario podremos

se puede usar para la creación de figuras geométricas en 2D y 3D respectivamente.

1. Qué es la línea oculta en computación gráfica

generalmente se representan por líneas segmentadas.

2. Describa que es la prueba de visibilidad

visibilidad al momento de realizarlo. Algoritmos simples que testean visibilidad (culling):

visualización para el usuario. Estos algoritmos muestrean el modelo y luego resuelven la

3. Cuál es el objetivo de eliminar la línea oculta

4. Que es un fractal y que características

Un fractal es un objeto geométrico en el que se repite el mismo patrón a diferentes escalas y

con diferente orientación.

Tienen varias características importantes, por ejemplo, Si un objeto fractal lo aumentamos,

decir cuál es de las ampliaciones es mayor o si son distintas.

inicio Mandelbrot, se dedicó al problema de medir la costa de Gran Bretaña usándolos.

Ejemplos de fractales en la vida cotidiana:

5. Dibuje un círculo inscrito en un triángulo, ingresando sus puntos

la lógica de programación de la misma.

aplicar la siguiente fórmula:

a estar situado dentro del círculo, de la siguiente manera:

que se va a dibujar y la unión de las líneas del mismo. De la siguiente manera:

manera general sería de la siguiente manera:

Principalmente creamos una interfaz, la cual va a interactuar con el usuario, el ingreso de

datos y que va a mostrar los resultados gráficos:

getters and setters:

primer punto, empezamos con la fórmula de la distancia, de la siguiente manera:

Posteriormente, Calculamos el Semiperímetro:

líneas que van a estar unidas al incentro:

private float mX, mY;

private float mAX, mAY;

private float mBX, mBY;

private float mCX, mCY;

private Graphics mGraph;

private const float SF = 20;

private Pen mPen;

// Creamos getters y setters

public float X { get => mX; set => mX = value; }

public float Y { get => mY; set => mY = value; }

mAX = 0.0f; mAY = 0.0f;

mBX = 0.0f; mBY = 0.0f;

mCX = 0.0f; mCY = 0.0f;

// constructor con 2 parametrs

public CEjercicio_5(float x, float y)

// constructor con 1 parametrs

//los datos del objeto se asignan a los datos miembros

// asignar datos directo al miembro de clase desde el objeto

// Función que permite leer los tres lados del triángulo.

public void ReadData(NumericUpDown numAX,

public CEjercicio_5 Triangle(float x, float y)

return (new CEjercicio_5(mX = x, mY = y));

public PointF VectortoPonitF(CEjercicio_5 V)

return new PointF(V.mX * SF, V.mY * SF);

//funcion que calcula la distancia

return (new CEjercicio_5((float)Math.Sqrt((Math.Pow((V.mX - U.mX),2) +