setXORMode, setPaintMode, Borrar una gráfica de muchas

[joseluisbz]

Cordial Saludo:

Estoy tratando de implementar una clase que me grafique diferentes señales; hasta ahora la clase grafica varias señales, la inquitud está es en borrar una de ellas.
Mi clase borra, pero deja vestigios de la señal que recien fue borrada u ocultada...

Pongo el código de mi clase para que por favor si pueden me ayuden... aclarar..

Código Java:

class Graficar extends javax.swing.JFrame {
  private int numVble;
  private Vector<Color> cVector = new Vector<Color>();    //Vector de Color de la Variable
  private Vector<String> nVector = new Vector<String>();  //Vector de Nombre de la Variable
  private Vector<Graphics2D> gVector = new Vector<Graphics2D>();//Vector de Graphic de la Variable
  private Vector<Double []> xVector = new Vector<Double []>();//Vector de Arreglo de X de la Variable
  private Vector<Double []> yVector = new Vector<Double []>();//Vector de Arreglo de Y de la Variable
  private Vector<Double> xMin = new Vector<Double>();//Vector de Valor Mínimo del Arreglo de X de la Variable
  private Vector<Double> yMin = new Vector<Double>();//Vector de Valor Mínimo del Arreglo de Y de la Variable
  private Vector<Double> xMax = new Vector<Double>();//Vector de Valor Máximo del Arreglo de X de la Variable
  private Vector<Double> yMax = new Vector<Double>();//Vector de Valor Máximo del Arreglo de Y de la Variable
  private Vector<Float> dVector = new Vector<Float>();//Vector de Espesor de la Variable
  private int PosX, PosY, Largo, Ancho;
  String VbleX, VbleY; //Agragar Nombre de Variables X y Y
  String TitleV, TitleH; //Agrega Título Vertical(Izquierda) y Título Horizontal(Debajo)
  String TitleM, TitleS; //Título Principal y Título Secundario
  Canvas Lienzo;
  private double MaxX, MinX, MaxY, MinY; //Almacena Máximos y Mínimos de Coordenadas X y Y
  Graficar(int xPos, int yPos, int xWidth, int yLarge){
    numVble = 0;
    Lienzo = new Canvas();
    setDimension(xWidth,yLarge);
    setPosition(xPos,yPos);
    Lienzo.setBackground(Color.LIGHT_GRAY);
    Lienzo.setForeground(Color.DARK_GRAY);
  }
  void setPosition(int xPos, int yPos) {
  //Asignar la posición del Lienzo
    PosX = xPos;
    PosY = yPos;
    Lienzo.setLocation(PosX, PosY);
  }
  void getPosition(int xPos, int yPos) {
  //Obtener la posición del Lienzo
    xPos = PosX;
    yPos = PosY;
  }
  void setDimension(int xWidth, int yLarge) {
  //Asignar la Dimensión del Lienzo
    Ancho = xWidth;
    Largo = yLarge;
    Lienzo.setSize(Ancho, Largo);
  }
  void getDimension(int xWidth, int yLarge) {
  //Obtener la Dimensión del Lienzo
    xWidth = Ancho;
    yLarge = Largo;
  }
  double getMax(double[] data){
  //Obtener el valor MAYOR del Arreglo
    if (data.length <1) throw new RuntimeException("Arreglo de datos vacío");
    double Max = data[0];
    for (int i=0;i<data.length;i++){
      if (Max < data[i])
        Max = data[i];
    }
    return Max;
  }
  double getMin(double[] data){
  //Obtener el valor MENOR del Arreglo
    if (data.length <1) throw new RuntimeException("Arreglo de datos vacío");
    double Min = data[0];
    for (int i=0;i<data.length;i++){
      if (Min > data[i])
        Min = data[i];
    }
    return Min;
  }
  double getMax(Vector<Double> data){
  //Obtener el valor MAYOR del Vector
    if (data.size() <1) throw new RuntimeException("Arreglo de datos vacío");
    double Max = data.elementAt(0);
    for (int i=0;i<data.size();i++){
      if (Max < data.elementAt(i))
        Max = data.elementAt(i);
    }
    return Max;
  }
  double getMin(Vector<Double> data){
  //Obtener el valor MENOR del Vector
    if (data.size() <1) throw new RuntimeException("Arreglo de datos vacío");
    double Min = data.elementAt(0);
    for (int i=0;i<data.size();i++){
      if (Min > data.elementAt(i))
        Min = data.elementAt(i);
    }
    return Min;
  }
  Double [] double_Double (double[] ddata){
  //Convierte los datos de double a Double para operar con Vectores
    Double[] Ddata = new Double[ddata.length];
    for (int i=0;i<ddata.length;i++){
      Ddata[i] = ddata[i];
    }
    return Ddata;
  }
  double [] Double_double (Double[] Ddata){
  //Restaura los datos de Double a double para operar con arreglos
    double[] ddata = new double[Ddata.length];
    for (int i=0;i<Ddata.length;i++){
      ddata[i] = Ddata[i];
    }
    return ddata;
  }
  int addVble(Graphics g, String nVble, double[] aX, double[] aY, Color VbleColor, float zDepth){
  //Agrega una variable a Graficar, llamada nVble, de Color VbleColor y Grosor zDepth
    if (nVector.contains(nVble)) throw new RuntimeException("La Variable ya existe");
    if(aX.length != aY.length) throw new RuntimeException("Tallas diferentes");
    if(aX.length == 0||aY.length == 0) throw new RuntimeException("Arreglos de datos vacíos");
    Graphics2D g2 = (Graphics2D)g;
    Double[] vX = double_Double(aX); //Convierte el Arreglo double vX a Vector Double vX
    Double[] vY = double_Double(aY); //Convierte el Arreglo double vY a Vector Double vY
    xMin.add(getMin(aX)); //Agrega el Mínimo valor del Arreglo aX al Vector xMin
    xMax.add(getMax(aX)); //Agrega el Máximo valor del Arreglo aX al Vector xMax
    yMin.add(getMin(aY)); //Agrega el Mínimo valor del Arreglo aY al Vector yMin
    yMax.add(getMax(aY)); //Agrega el Máximo valor del Arreglo aY al Vector yMin
    nVector.add(nVble);
    cVector.add(VbleColor);
    dVector.add(zDepth);
    gVector.add(g2);
    xVector.add(vX);
    yVector.add(vY);
    
    MinX = getMin(xMin);  //Halla el Mínimo Valor de X, del Vector xMin
    MaxX = getMax(xMax);  //Halla el Máximo Valor de X, del Vector xMax
    MinY = getMin(yMin);  //Halla el Mínimo Valor de Y, del Vector yMin
    MaxY = getMax(yMax);  //Halla el Máximo Valor de Y, del Vector yMax
 
    System.out.print("addVble \n");
    System.out.print(nVble+" getMin(aX):"+getMin(aX)+" MinX :"+MinX+"\n");
    System.out.print(nVble+" getMax(aX):"+getMax(aX)+" MaxX :"+MaxX+"\n");
    System.out.print(nVble+" getMin(aY):"+getMin(aY)+" MinY :"+MinY+"\n");
    System.out.print(nVble+" getMax(aY):"+getMax(aY)+" MaxY :"+MaxY+"\n");
    System.out.print(" \n");
    numVble += 1;
    return numVble;
  }
  int numVble() {
  //Retorna el número de variables que hay almacenadas
    return numVble;
  }
  int delVble(String nVble){
  //Elimina una variable a Graficar llamada nVble
    if (!nVector.contains(nVble)) throw new RuntimeException("La Variable no existe");
    int Indice = nVector.indexOf(nVble);
    xMin.remove(Indice);  //Borra el Mínimo valor de X del Vector xMin
    xMax.remove(Indice);  //Borra el Máximo valor de X del Vector xMin
    yMin.remove(Indice);  //Borra el Mínimo valor de Y del Vector yMin
    yMax.remove(Indice);  //Borra el Máximo valor de Y del Vector yMin
    nVector.remove(Indice);
    cVector.remove(Indice);
    dVector.remove(Indice);
    gVector.remove(Indice);
    xVector.remove(Indice);
    yVector.remove(Indice);
 
    MinX = getMin(xMin);  //Halla el Mínimo Valor de X, del Vector xMin
    MaxX = getMax(xMax);  //Halla el Máximo Valor de X, del Vector xMax
    MinY = getMin(yMin);  //Halla el Mínimo Valor de Y, del Vector yMin
    MaxY = getMax(yMax);  //Halla el Máximo Valor de Y, del Vector yMax
 
    System.out.print("delVble \n");
    System.out.print(nVble+" MinX :"+MinX+"\n");
    System.out.print(nVble+" MaxX :"+MaxX+"\n");
    System.out.print(nVble+" MinY :"+MinY+"\n");
    System.out.print(nVble+" MaxY :"+MaxY+"\n");
    System.out.print(" \n");
    numVble -= 1;
    return numVble;
  }
  boolean Exist(String nVble){
  //Verifica si existe una Variable llamada nVble
    return nVector.contains(nVble);
  }
  void ViewAll(){
  //Muestra todas las graficas almacenadas en los vectores
    for (int Indice = 0; Indice<nVector.size();Indice++){
      grafica(Indice, "View");
    }
  }
  void HideAll(){
  //Oculta todas las graficas almacenadas en los vectores
    for (int Indice = 0; Indice<nVector.size();Indice++){
      grafica(Indice, "Hide");
    }
  }
  void ViewVble(String nVble){
  //Muestra la grafica de la Variable llamada nVble
    if (!nVector.contains(nVble)) throw new RuntimeException("La Variable no existe");
    int Indice = nVector.indexOf(nVble);
    grafica(Indice, "View");
  }
  void HideVble(String nVble){
  //Oculta la grafica de la Variable llamada nVble
    if (!nVector.contains(nVble)) throw new RuntimeException("La Variable no existe");
    int Indice = nVector.indexOf(nVble);
    grafica(Indice, "Hide");
  }
  void grafica(int Indice, String Oper){
  //Recarga una gráfica para mostrarla u ocultarla
    Graphics2D g2 = gVector.elementAt(Indice);
    float zDepth = dVector.elementAt(Indice);
    Color color = cVector.elementAt(Indice);
    double[] aX = Double_double(xVector.elementAt(Indice));
    double[] aY = Double_double(yVector.elementAt(Indice));
    g2.setColor(color);
    g2.setStroke(new BasicStroke(zDepth));
    if (Oper.equals("Hide")){
      g2.setXORMode(getBackground());
    }
    if (Oper.equals("View")){
      g2.setPaintMode();
    }
    if (aX.length == 1){
      g2.drawLine ((int)aX[0], (int)aX[0], (int)aY[0], (int)aY[0]);
    } else {
      for (int j = 0;j<aY.length-1;j++){
        //g2.draw( new Line2D.Double((int)vX[i], (int)vX[i+1], (int)vY[i], (int)vY[i+1]));
        g2.drawLine ((int)aX[j], (int)aY[j], (int)aX[j+1], (int)aY[j+1]);
      }
    }
    repaint();
  }
  String[] AllVbles(){
  //Retorna un vector con los nombres de las variables almacenadas
    String[] Vbles = new String[nVector.size()];
    for (int i = 0; i<nVector.size();i++){
      Vbles[i] = nVector.elementAt(i);
    }
    return Vbles;
  }
}
 

[joseluisbz]

El modo de uso es el siguiente:

Código Java:

public void paint( Graphics g ) {
  super.paint( g );
  Graficar MisGraficos = new Graficar(10,10,400,400);
  double misT[] = {100,120,140,160,180,200,220,240};
  double misX[] = {110,120,230,140,150,160,270,180};
  double misY[] = {140,55,90,200,140,124,210,60};
  double misZ[] = {125,300,170,150,110,110,200,100};
  MisGraficos.addVble(g,"a", misT, misX, Color.RED, (float)1);
  MisGraficos.addVble(g,"b", misT, misY, Color.GREEN, (float)1.1);
  MisGraficos.addVble(g,"c", misT, misZ, Color.BLUE, (float)1.2);
  MisGraficos.ViewAll();
  MisGraficos.HideVble("a");
  MisGraficos.delVble("c");
  MisGraficos.HideAll();
} // fin del método paint
 

primero que todo defino unas variables del tipo X versus Y,
en el arreglo misT[] hágase de cuenta que es el tiempo y misX[], misY[], misY[] son las funciones que deben tener el mismo número de datos.

Agrego las variables, el nombre, lo datos de X y los datos de Y por último el color y el grosor de la linea de dibujo.
Todo sale bien hasta cuando llamo:
MisGraficos.HideVble("a");
Quedan vestigios de la señal, es decir, aunque "oculte" la señal se quedan viendo pedazos de lineas rojas...

Por favor de tener una duda acerca de mi clase porque no entiendan yo les explico con mucho gusto...

Pienso yo que uno de los motivos es el uso de setXORMode, setPaintMode... bueno agradezco por adelantado su colaboración..

[chepelucho]

Aun no has solucionada nada?

[joseluisbz]

El mensaje no tuvo respuesta... será porque el código es muy largo?
Voy a tratar de poner algo más entendible...

Le cambié el nombre a la clase... de Graficar a GTrama... para indicar que hereda de Frame

Código Java:

class GTrama extends Frame {
  private Vector<Color> cVector = new Vector<Color>();    //Vector de Color de la Variable
  private Vector<Boolean> vVector = new Vector<Boolean>();    //Vector de Visibilidad de la Variable
  private Vector<String> nVector = new Vector<String>();  //Vector de Nombre de la Variable
  private Vector<Graphics2D> gVector = new Vector<Graphics2D>();//Vector de Graphic de la Variable
  private Vector<Double []> xVector = new Vector<Double []>();//Vector de Arreglo de X de la Variable
  private Vector<Double []> yVector = new Vector<Double []>();//Vector de Arreglo de Y de la Variable
  private Vector<Double> xMin = new Vector<Double>();//Vector de Valor Mínimo del Arreglo de X de la Variable
  private Vector<Double> yMin = new Vector<Double>();//Vector de Valor Mínimo del Arreglo de Y de la Variable
  private Vector<Double> xMax = new Vector<Double>();//Vector de Valor Máximo del Arreglo de X de la Variable
  private Vector<Double> yMax = new Vector<Double>();//Vector de Valor Máximo del Arreglo de Y de la Variable
  private Vector<Float> dVector = new Vector<Float>();//Vector de Espesor de la Variable
  private int PosX, PosY, Largo, Ancho;
  String VbleX, VbleY; //Agragar Nombre de Variables X y Y
  String TitleV, TitleH; //Agrega Título Vertical(Izquierda) y Título Horizontal(Debajo)
  String TitleM, TitleS; //Título Principal y Título Secundario
  private double MaxX, MinX, MaxY, MinY; //Almacena Máximos y Mínimos de Coordenadas X y Y
  
  GTrama(int xPos, int yPos, int xWidth, int yLarge){
  }
 
  void ViewAll(Graphics g){
  //Muestra todas las graficas almacenadas en los vectores
    for (int Indice = 0; Indice<nVector.size();Indice++){
      grafica(g, Indice, "View");
    }
  }
  void HideAll(Graphics g){
  //Oculta todas las graficas almacenadas en los vectores
    for (int Indice = 0; Indice<nVector.size();Indice++){
      grafica(g, Indice, "Hide");
    }
  }
  void ViewVble(Graphics g, String nVble){
  //Muestra la grafica de la Variable llamada nVble
    if (!nVector.contains(nVble)) throw new RuntimeException("La Variable no existe");
    int Indice = nVector.indexOf(nVble);
    grafica(g, Indice, "View");
  }
  void HideVble(Graphics g, String nVble){
  //Oculta la grafica de la Variable llamada nVble
    if (!nVector.contains(nVble)) throw new RuntimeException("La Variable no existe");
    int Indice = nVector.indexOf(nVble);
    grafica(g, Indice, "Hide");
  }
}
 

Como NO pude implementar un arreglo de tipo double:

Código Java:

private Vector<double []> xVector = new Vector<double []>();
private Vector<double []> yVector = new Vector<double []>();
 

Me tocó hacer un Vector de tipo arreglo de Objeto tipo Double:

Código Java:

private Vector<Double []> xVector = new Vector<Double []>();
private Vector<Double []> yVector = new Vector<Double []>();
 

HE EXTRAIDO LOS MÉTODOS DE LA CLASE PARA EXPLICARLOS POR FUERA, PERO REALMENTE SON MÉTODOS DE GTrama

Y por supuesto no pude hacer uso de System.ArrayCopy más bien hacer la copia o conversión manual...

Código Java:

Double [] double_Double (double[] ddata){
  //Convierte los datos de double a Double para operar con Vectores
    Double[] Ddata = new Double[ddata.length];
    for (int i=0;i<ddata.length;i++){
      Ddata[i] = ddata[i];
    }
    return Ddata;
  }
  double [] Double_double (Double[] Ddata){
  //Restaura los datos de Double a double para operar con arreglos
    double[] ddata = new double[Ddata.length];
    for (int i=0;i<Ddata.length;i++){
      ddata[i] = Ddata[i];
    }
    return ddata;
  }
 

Es por ello que me tocó implementar dos métodos para hallar los mínimos y dos métodos para hallar los máximos...

Código Java:

double getMax(double[] data){
  //Obtener el valor MAYOR del Arreglo
    if (data.length <1) throw new RuntimeException("Arreglo de datos vacío");
    double Max = data[0];
    for (int i=0;i<data.length;i++)
      if (Max < data[i])
        Max = data[i];
    return Max;
  }
  double getMin(double[] data){
  //Obtener el valor MENOR del Arreglo
    if (data.length <1) throw new RuntimeException("Arreglo de datos vacío");
    double Min = data[0];
    for (int i=0;i<data.length;i++)
      if (Min > data[i])
        Min = data[i];
    return Min;
  }
  double getMax(Vector<Double> data){
    if (data.size() <1) throw new RuntimeException("Arreglo de datos vacío");
    double Max = data.elementAt(0);
    for (int i=0;i<data.size();i++)
      if (Max < data.elementAt(i))
        Max = data.elementAt(i);
    return Max;
  }
  double getMin(Vector<Double> data){
    if (data.size() <1) throw new RuntimeException("Arreglo de datos vacío");
    double Min = data.elementAt(0);
    for (int i=0;i<data.size();i++)
      if (Min > data.elementAt(i))
        Min = data.elementAt(i);
    return Min;
  }
 

Agregar una Variable a los vectores de la clase...

Código Java:

int addVble(Graphics g, String nVble, double[] aX, double[] aY, Color VbleColor, float zDepth, boolean bVisible){
  //Agrega una variable a Graficar, llamada nVble, de Color VbleColor y Grosor zDepth
    if (nVector.contains(nVble)) throw new RuntimeException("La Variable ya existe");
    if(aX.length != aY.length) throw new RuntimeException("Tallas diferentes");
    if(aX.length == 0||aY.length == 0) throw new RuntimeException("Arreglos de datos vacíos");
    Graphics2D g2 = (Graphics2D)g;
 
    //Agrega el Mínimo y el Máximo valor de los Arreglos aX y aY a los Vectores xMin, XMax, yMin y yMax
    xMin.add(getMin(aX));
    xMax.add(getMax(aX));
    yMin.add(getMin(aY));
    yMax.add(getMax(aY));
    gVector.add(g2);
    nVector.add(nVble);
    Double[] vX = double_Double(aX); //Convierte el Arreglo double vX a Vector Double vX
    Double[] vY = double_Double(aY); //Convierte el Arreglo double vY a Vector Double vY
    xVector.add(vX);
    yVector.add(vY);
    cVector.add(VbleColor);
    dVector.add(zDepth);
    vVector.add(bVisible);
 
    //Halla el Mínimo Valor xMin y yMin y el Máximo valor de xMax y yMax
    MinX = getMin(xMin);
    MaxX = getMax(xMax);
    MinY = getMin(yMin);
    MaxY = getMax(yMax);
    return nVector.size();
  }
 

Borrar una variable de los vectores...

Código Java:

int delVble(String nVble){
  //Elimina una variable a Graficar llamada nVble
    if (!nVector.contains(nVble)) throw new RuntimeException("La Variable no existe");
    int Indice = nVector.indexOf(nVble);
    xMin.remove(Indice);
    xMax.remove(Indice);
    yMin.remove(Indice);
    yMax.remove(Indice);
    gVector.remove(Indice);
    nVector.remove(Indice);
    xVector.remove(Indice);
    yVector.remove(Indice);
    cVector.remove(Indice);
    dVector.remove(Indice);
    vVector.remove(Indice);
 
    //Halla el Mínimo Valor xMin y yMin y el Máximo valor de xMax y yMax
    MinX = getMin(xMin);  
    MaxX = getMax(xMax);
    MinY = getMin(yMin);
    MaxY = getMax(yMax);
    return nVector.size();
  }
 

ACA ESTA La DUDA FUERTE
Método grafica..lo que hace es graficar u ocultar las lineas de alguna variable indicada en la variable Indice... g2.setXORMode(getBackground()); Por ejemplo al tratar de borrar una línea me deja unos punticos, es decir, no la borra toda...

Código Java:

void grafica(Graphics g, int Indice, String Oper){
  //Recarga una gráfica para mostrarla u ocultarla
    Graphics2D g2 = gVector.elementAt(Indice);
    Color color = cVector.elementAt(Indice);
    double[] aX = Double_double(xVector.elementAt(Indice));
    double[] aY = Double_double(yVector.elementAt(Indice));
    g2.setColor(color);
    g2.setStroke(new BasicStroke(zDepth));
    if (Oper.equals("Hide")){
      g2.setXORMode(getBackground());
    }
    if (Oper.equals("View")){
      g2.setPaintMode();
    }
    if (aX.length == 1){
      g2.drawLine ((int)aX[0], (int)aX[0], (int)aY[0], (int)aY[0]);
    } else {
      for (int j = 0;j<aY.length-1;j++){
        g2.drawLine ((int)aX[j], (int)aY[j], (int)aX[j+1], (int)aY[j+1]);
      }
    }
    g.drawImage(GrafImagen, PosX, PosX, this);
    //repaint();
  }
 

Aca está la manera en que uso la clase...

Código Java:

public void paint( Graphics g ) {
    GTrama MisGraficos = new GTrama(10,10,400,400);
    double misT[] = {100,120,140,160,180,200,220,240};
    double misX[] = {110,120,230,140,150,160,270,180};
    double misY[] = {140,55,90,200,140,124,210,60};
    double misZ[] = {125,300,170,150,110,110,200,100};
    MisGraficos.addVble(g ,"a", misT, misX, Color.RED, (float)1, true);
    MisGraficos.addVble(g ,"b", misT, misY, Color.GREEN, (float)1.1,true);
    MisGraficos.addVble(g ,"c", misT, misZ, Color.BLUE, (float)1.2, true);
    MisGraficos.ViewAll(g );
  }
 

Por favor si aún no se entiende mi código por favor me avisan

[chuidiang]

Hola:

En general borrar pintando encima es bastante complejo, precisamente por lo que te está sucediendo, se quedan puntitos sin borrar.

Si quieres hacerlo así, tienes que asegurarte muy mucho de que los puntos x,y que borras son exactamente los que pintas, haciendo exactamente las mismas cuentas o guardándolos en algún sitio para borrarlos después sin necesidad de calcularlos.

El xor mode presenta además otro problema. Imagina que pintas en modo normal el mismo pixel dos veces, porque han salido dos puntos x,y distintos pero al redondearlos, caen en el mismo pixel

(1.2, 2.3) ---> se pinta en pixel 1,2
(1.3, 2.4) ---> se pinta también en pixel 1,2

Como es modo de pintado normal, el punto queda pintado. Ahora quieres borrarlo echando las mismas cuentas y con xor. Vas a pintar dos veces con xor el mismo punto en pixels. El primer pintado te lo borrará, pero el segundo te lo volverá a pintar. Si estás echando exactamente las mismas cuentas para borrar (parece que sí), quizás los puntitos que te quedan son porque en el mismo pixel caen varios puntos distintos (un número par) de la gráfica.

No tengo muy claro lo que haces en el código, pero ¿no puedes borrar pintando del color del background?. Normalmente se borra con xor si se pinta también con xor, es una forma de respetar el fondo u otras gráficas que haya por debajo, pero hay que pintar también con xor, ya que si pintas de forma normal, "machacas" el fondo al pintar y al borrar con xor usando el mismo color, obtendrás directamente negro, no el fondo original que hubiera.

Es cualquier caso, es casi mejor borrar todo y repintarlo entero, o guardar cada trozo en un BufferedImage distinto y luego componerlos. Se supone que es menos eficiente, pero si el número de puntos de las gráficas que quieras pintar no es muy grande, puede no notarse diferencia y tienes que ver también si es más eficiente pintarlo todo cada vez o echar todas las cuentas que necesitarás para asegurarte del perfecto borrado.

Se bueno.

[joseluisbz]

Cada gráfica tiene la información necesaria para borrarla

Nombre, que es único y con la cual se identifican las funciones o variables:

Código Java:

private Vector<String> nVector = new Vector<String>();
 

Color, el color con el cual se debe dibujar

Código Java:

private Vector<Color> cVector = new Vector<Color>();
 

Espesor de Línea:

Código Java:

private Vector<Float> dVector = new Vector<Float>();
 

Datos de la función en parejas tipo X y Y

Código Java:

private Vector<Double []> xVector = new Vector<Double []>();
private Vector<Double []> yVector = new Vector<Double []>();
 

Información de tipo Graphic

Código Java:

private Vector<Graphics2D> gVector = new Vector<Graphics2D>();
 

Visibilidad: (No está implementada del todo) Es un atributo que permitiría en vez de usar setXORMode, borrar todas las gráficas y graficar todas las variables cuya visibilidad sea "true" y dejar ocultadas aquellas cuya visibilidad sea false.

Código Java:

private Vector<Boolean> vVector = new Vector<Boolean>();
 

La cuestión o duda está en que debe haber un orden para usar setXORMode?


Por otro lado esto se presenta al usar esos métodos...

Código Java:

public void paint( Graphics g ) {
  GTrama MisGraficos = new GTrama(10,10,400,400);
  double misT[] = {100,120,140,160,180,200,220,240};
  double misX[] = {110,120,230,140,150,160,270,180};
  double misY[] = {140,55,90,200,140,124,210,60};
  double misZ[] = {125,300,170,150,110,110,200,100};
  MisGraficos.addVble(g ,"a", misT, misX, Color.RED, (float)1, true);
  MisGraficos.addVble(g ,"b", misT, misY, Color.GREEN, (float)1.1,true);
  MisGraficos.addVble(g ,"c", misT, misZ, Color.BLUE, (float)1.2, true);
  MisGraficos.ViewAll(g );
  MisGraficos.HideVble(g,"a");
  MisGraficos.delVble("c");
  MisGraficos.HideAll(g);
}
 

Como se puede ver, los métodos HideVble y/o HideAll, utilizan los mismos valores de espesor de su gráfica respectiva por lo que no deben quedar vestigios...

[chuidiang]

Sí, pero queda el segundo tema que te dije. Si al borrar hay dos puntos de la gráfica que coinciden sobre el mismo pixel, no se borrará dicho pixel, ya que el primer xor lo borra, pero el segundo vuelve a pintarlo.

Se bueno.

[joseluisbz]

Para evitar eso que me dices....

Iniciado por chuidiang

Sí, pero queda el segundo tema que te dije. Si al borrar hay dos puntos de la gráfica que coinciden sobre el mismo pixel, no se borrará dicho pixel, ya que el primer xor lo borra, pero el segundo vuelve a pintarlo.

Se bueno.

He cambiado el funcionamiento del método paint...
No estoy seguro de si llamar al método super.paint(g1d);..
Luego paint "configura" los vectores llamando al método dibujar(g1d);
Llama al método MisGraficos.graficar(g1d); para mostrar los datos detallados en el método dibujar...

Código Java:

public void paint(Graphics g) {
    g1d = g;
    super.paint(g1d);
    dibujar(g1d);  //Si saco esto de aca no realiza los cambios en los vectores
    if (MisGraficos!=null){
      MisGraficos.graficar(g1d);
    }
  }
 

El método dibujar hace todos los cambios (agregar variable, borrarla, visualizarla, ocultar todas las variables, o visualizarlas, etc..) que el usuario de la clase quiere hacer en los vectores de las variables.

Código Java:

public void dibujar(Graphics g){
    // super.paint( g);
    double misT[] = {100,120,140,160,180,200,220,240};
    double misX[] = {120,120,160,160,160,140,140,140};
    double misY[] = {140,140,120,120,120,160,160,160};
    double misZ[] = {160,160,140,140,140,120,120,120};
    double misP[] = {200,200,220,220,240,240,260,260};
    double misQ[] = {260,260,240,240,220,220,200,200};
    MisGraficos = new GTrama(10,10,400,400);
    MisGraficos.addVble(g,"a", misT, misX, Color.RED, (float)1, false);
    MisGraficos.addVble(g,"b", misT, misY, Color.GREEN, (float)1,false);
    MisGraficos.addVble(g,"c", misT, misZ, Color.BLUE, (float)1, false);
    MisGraficos.addVble(g,"d", misT, misP, Color.LIGHT_GRAY, (float)2, false);
    MisGraficos.addVble(g,"e", misT, misQ, Color.DARK_GRAY, (float)2,false);
    MisGraficos.ViewAll();
    MisGraficos.HideAll();
    MisGraficos.ViewVble("e");
    MisGraficos.ViewVble("d");
    MisGraficos.delVble("c");
  }
 

El método graficar revisa el contenido del Vector nVector (que contiene el nombre de las variables) y verifica si el vVector correspondiente de la variable es visible o no (true->Visible, false->Oculto), Si es visible llama al método grafica para visualizar la variable en cuestión, pasándole el objeto Graphics, el Indice de referencia (así se cargan los datos de los vectores de la variable) y la Palabra "View".

Código Java:

void graficar(Graphics g){
    if (!nVector.isEmpty()){
      for (int Indice = 0; Indice<nVector.size();Indice++){
        if (vVector.elementAt(Indice)){
          grafica(g, Indice, "View");
        }
      }
    }
  }
 

El método grafica, solo visualizará los datos de la variable elegida, y usará g2.setPaintMode();

Código Java:

void grafica(Graphics g, int Indice, String Oper){
  //Recarga una gráfica para mostrarla u ocultarla
    Graphics2D g2 = gVector.elementAt(Indice)
//    Graphics2D g2 = (Graphics2D)g;
 
    float zDepth = dVector.elementAt(Indice);
    Color color = cVector.elementAt(Indice);
    double[] aX = Double_double(xVector.elementAt(Indice));
    double[] aY = Double_double(yVector.elementAt(Indice));
    g2.setColor(color);
    g2.setStroke(new BasicStroke(zDepth));
    if (Oper.equals("Hide")){
      g2.setXORMode(getBackground());
    }
    if (Oper.equals("View")){
      g2.setPaintMode();
    }
    if (aX.length == 1){
      g2.drawLine ((int)aX[0], (int)aX[0], (int)aY[0], (int)aY[0]);
    } else {
      System.out.print(nVector.elementAt(Indice)+"\n");
      for (int j = 0;j<aY.length-1;j++){
        g2.drawLine ((int)aX[j], (int)aY[j], (int)aX[j+1], (int)aY[j+1]);
      }
    }+
  }
 

Todo lo anterior funciona, puesto que puedo ver las gráficas...

La pregunta es si yo saco al método dibujar del método paint y lo pongo en un botón de esta manera:

Código Java:

private void jbDibujarActionPerformed(java.awt.event.ActionEvent evt) {  
    dibujar(g1d);
    paint(g1d);
//    repaint();
  }
 

¿Porqué no me dibuja al presionar el botón?

La idea anterior es que Paint no cambie los vectores solo los muestre.

Código Java:

public void paint(Graphics g) {
    g1d = g;
    super.paint(g1d);
    if (MisGraficos!=null){
      MisGraficos.graficar(g1d);
    }
  }
 

Los cambios se realizarían al presionar el botón quien llama a repaint, update o paint (cualquiera que sea el caso). ¿Pero porqué no funciona?

[joseluisbz]

Si alguien me puede dar una mano por favor...
Bueno he puesto como tengo definida mi clase GTrama, se llama así porque hereda de Frame..
¿Habría alguna diferencia si la pongo a heredar de Canvas?
O si creo una nueva clase que se llame GCanvas que herede de canvas y que tenga un miembro de la clase GTrama

Código Java:

class GLienzo extends Canvas {
  GTrama Trama;
  GLienzo(GTrama gt){Trama = gt;}
  public void update(Graphics g) { Trama.graficar(g); }
  public void paint(Graphics g) { Trama.graficar(g); }
}
 

Les estaré agradecido...

[joseluisbz]

SOLUCIONADO

Primero describiré las clases:

Código Java:

class GTrama extends Frame {
  private Vector<Color> cVector = new Vector<Color>();
  private Vector<Boolean> vVector = new Vector<Boolean>();
  private Vector<String> nVector = new Vector<String>();
  private Vector<Double []> xVector = new Vector<Double []>();
  private Vector<Double []> yVector = new Vector<Double []>();
  private Vector<Double> xMin = new Vector<Double>();
  private Vector<Double> yMin = new Vector<Double>();
  private Vector<Double> xMax = new Vector<Double>();
  private Vector<Double> yMax = new Vector<Double>();
  private Vector<Float> dVector = new Vector<Float>();
  private double MaxX, MinX, MaxY, MinY;
 
  GTrama(){
  }
  ...
}
 

Métodos de conversión de tipo de datos de Double a double y viceversa de la clase GTrama

Código Java:

Double [] double_Double (double[] ddata){
  //Convierte los datos de double a Double para operar con Vectores
    Double[] Ddata = new Double[ddata.length];
    for (int i=0;i<ddata.length;i++){
      Ddata[i] = ddata[i];
    }
    return Ddata;
  }
 
  double [] Double_double (Double[] Ddata){
  //Restaura los datos de Double a double para operar con arreglos
    double[] ddata = new double[Ddata.length];
    for (int i=0;i<Ddata.length;i++){
      ddata[i] = Ddata[i];
    }
    return ddata;
  }
 

Métodos para hallar máximos y mínimos de la clase GTrama

Código Java:

double getMax(double[] data){
  //Obtener el valor MAYOR del Arreglo
    if (data.length <1) throw new RuntimeException("Arreglo de datos vacío");
    double Max = data[0];
    for (int i=0;i<data.length;i++){
      if (Max < data[i])
        Max = data[i];
    }
    return Max;
  }
  double getMin(double[] data){
  //Obtener el valor MENOR del Arreglo
    if (data.length <1) throw new RuntimeException("Arreglo de datos vacío");
    double Min = data[0];
    for (int i=0;i<data.length;i++){
      if (Min > data[i])
        Min = data[i];
    }
    return Min;
  }
  double getMax(Vector<Double> data){
  //Obtener el valor MAYOR del Vector
    if (data.size() <1) throw new RuntimeException("Arreglo de datos vacío");
    double Max = data.elementAt(0);
    for (int i=0;i<data.size();i++){
      if (Max < data.elementAt(i))
        Max = data.elementAt(i);
    }
    return Max;
  }
  double getMin(Vector<Double> data){
  //Obtener el valor MENOR del Vector
    if (data.size() <1) throw new RuntimeException("Arreglo de datos vacío");
    double Min = data.elementAt(0);
    for (int i=0;i<data.size();i++){
      if (Min > data.elementAt(i))
        Min = data.elementAt(i);
    }
    return Min;
  }
 

Métodos de visualización y ocultamiento de las variables en los vectores en la clase GTrama

Código Java:

void ViewAll(){
  //Muestra todas las graficas almacenadas en los vectores
    for (int Indice = 0; Indice<nVector.size();Indice++){
      vVector.set(Indice, true);
    }
  }
  void HideAll(){
  //Oculta todas las graficas almacenadas en los vectores
    for (int Indice = 0; Indice<nVector.size();Indice++){
      vVector.set(Indice, false);
    }
  }
  void ViewVble(String nVble){
  //Muestra la grafica de la Variable llamada nVble
    if (!nVector.contains(nVble)) throw new RuntimeException("La Variable no existe");
    int Indice = nVector.indexOf(nVble);
    vVector.set(Indice, true);
  }
  void HideVble(String nVble){
  //Oculta la grafica de la Variable llamada nVble
    if (!nVector.contains(nVble)) throw new RuntimeException("La Variable no existe");
    int Indice = nVector.indexOf(nVble);
    vVector.set(Indice, false);
  }
 

El método addVble ya no hace referencia ningún objeto Graphics, ni se almacena (no se necesita)

Código Java:

int addVble(String nVble, double[] aX, double[] aY, Color VbleColor, float zDepth, boolean bVisible){
  //Agrega una variable a Graficar, llamada nVble, de Color VbleColor y Grosor zDepth
    if (nVector.contains(nVble)) throw new RuntimeException("La Variable ya existe");
    if(aX.length != aY.length) throw new RuntimeException("Tallas diferentes");
    if(aX.length == 0||aY.length == 0) throw new RuntimeException("Arreglos de datos vacíos");
    xMin.add(getMin(aX));
    xMax.add(getMax(aX));
    yMin.add(getMin(aY));
    yMax.add(getMax(aY));
    nVector.add(nVble);
    Double[] vX = double_Double(aX);
    Double[] vY = double_Double(aY);
    xVector.add(vX);
    yVector.add(vY);
    cVector.add(VbleColor);
    dVector.add(zDepth);
    vVector.add(bVisible);
 
    MinX = getMin(xMin);
    MaxX = getMax(xMax);
    MinY = getMin(yMin);
    MaxY = getMax(yMax);
    return nVector.size();
  }
 

El método delVble ya no hace referencia ningún objeto Graphics, ni se elimina (no existe)

Código Java:

int delVble(String nVble){
  //Elimina una variable a Graficar llamada nVble
    if (!nVector.contains(nVble)) throw new RuntimeException("La Variable no existe");
    int Indice = nVector.indexOf(nVble);
    xMin.remove(Indice);
    xMax.remove(Indice);
    yMin.remove(Indice);
    yMax.remove(Indice);
    nVector.remove(Indice);
    xVector.remove(Indice);
    yVector.remove(Indice);
    cVector.remove(Indice);
    dVector.remove(Indice);
    vVector.remove(Indice);
 
    MinX = getMin(xMin);
    MaxX = getMax(xMax);
    MinY = getMin(yMin);
    MaxY = getMax(yMax);
    return nVector.size();
  }
 

El nuevo objeto referente gráfico es de tipo BufferedImage

Código Java:

void PlotAll(BufferedImage bi){
  //Grafica todas las variables Visibles almacenadas en los vectores
    if (!nVector.isEmpty()){
      for (int Indice = 0; Indice<nVector.size();Indice++){
        if (vVector.elementAt(Indice)){
          PlotVble(bi, Indice);
        }
      }
    }
  }
 

El nuevo objeto referente gráfico es de tipo BufferedImage

Código Java:

void PlotVble(BufferedImage bi, int Indice){
  //Recarga una gráfica para mostrarla
    Graphics2D g2d = bi.createGraphics();
    float zDepth = dVector.elementAt(Indice);
    Color color = cVector.elementAt(Indice);
    double[] aX = Double_double(xVector.elementAt(Indice));
    double[] aY = Double_double(yVector.elementAt(Indice));
    g2d.setColor(color);
    g2d.setStroke(new BasicStroke(zDepth));
    g2d.setPaintMode();
    if (aX.length == 1){
      g2d.drawLine ((int)aX[0], (int)aX[0], (int)aY[0], (int)aY[0]);
    } else {
      for (int j = 0;j<aY.length-1;j++){
        g2d.drawLine ((int)aX[j], (int)aY[j], (int)aX[j+1], (int)aY[j+1]);
      }
    }
    g2d.dispose();
  }
 

Forma de Uso

Código Java:

public class Graficador extends javax.swing.JFrame {
    /** Creates new form Graficador */
  GTrama MisGraficos;
  public Graficador() {
    super( "Dibujo de figuras en 2D" );
    setVisible(true);
    initComponents();
    bImage = new  BufferedImage(super.getWidth(),super.getHeight(),BufferedImage.TYPE_INT_RGB);   
  }
 
  public void paint(Graphics g) {
    super.paint(g);
    if (MisGraficos!=null){
      MisGraficos.PlotAll(bImage);
    }
    g.drawImage(bImage, 0, 0, this);
  }
 
   private void jbDibujarActionPerformed(java.awt.event.ActionEvent evt) {
    dibujar();
    repaint();
   }
 

El método dibujar agrega las variables a los vectores y manipula su presentación

Código Java:

public void dibujar(){
    // super.paint( Grafica );
    double misT[] = {100,120,140,160,180,200,220,240};
    double misX[] = {120,120,160,160,160,140,140,140};
    double misY[] = {140,140,120,120,120,160,160,160};
    double misZ[] = {160,160,140,140,140,120,120,120};
    double misP[] = {200,200,220,220,240,240,260,260};
    double misQ[] = {260,260,240,240,220,220,200,200};
    MisGraficos = new GTrama(10,10,400,400);
    MisGraficos.addVble("a", misT, misX, Color.RED, (float)1, false);
    MisGraficos.addVble("b", misT, misY, Color.GREEN, (float)1,false);
    MisGraficos.addVble("c", misT, misZ, Color.BLUE, (float)1, false);
    MisGraficos.addVble("d", misT, misP, Color.LIGHT_GRAY, (float)2, false);
    MisGraficos.addVble("e", misT, misQ, Color.DARK_GRAY, (float)2,false);
    MisGraficos.ViewAll();
    MisGraficos.ViewVble("e");
    MisGraficos.ViewVble("d");
  }
 

El botón jbDibujar llama al método dibujar que inicializa los vectores, luego del repaint, se pinta la información contenida en los vectores.

Gracias por su ayuda...