✔ Koordinatensystem

Na dann lässt du es entweder skalieren (AffineTransform) oder du Zeichnest gleich in einem anderen Maßstab (siehe meinen Post auf der letzten Seite als Beispiel)
 
Hi,

ich glaube nicht, dass das was Du machen möchstest in dieser Weise möglich ist, oder ich habe es immer noch nicht verstanden.

Wenn Du eine Art Lupe einbauen willst, hat das immer den Nachteil, dass einige Pixel nicht zu sehen sein werden. Ich denke, Du kannst das Problem nur durch Achsen lösen, die nicht homogen skalier sind, sondern so wie in meinem letzten Post beschrieben.

Das heißt, dass Du nahe bei den Achsen eine andere Einteilung hast, als in größerer Entfernung zu den Achsen.

Das würde das Problem der Hervorherbung lösen, aber zwei neue schaffen:

1. Du hättest 9 Bereiche mit verschiedenen Transformationen
2. Die Kurven wären optisch verzerrt.

Warum kannst Du kein Ausschnittsfenster für den inneren Bereich machen. dann wärst Du doch alle Probleme los?

Erzähl doch mal was zum Hintergrund, vielleicht ist es dann besser zu verstehen.
 
limago hat gesagt.:
Hi,

ich glaube nicht, dass das was Du machen möchstest in dieser Weise möglich ist, oder ich habe es immer noch nicht verstanden.

Wenn Du eine Art Lupe einbauen willst, hat das immer den Nachteil, dass einige Pixel nicht zu sehen sein werden. Ich denke, Du kannst das Problem nur durch Achsen lösen, die nicht homogen skalier sind, sondern so wie in meinem letzten Post beschrieben.

Das heißt, dass Du nahe bei den Achsen eine andere Einteilung hast, als in größerer Entfernung zu den Achsen.

Das würde das Problem der Hervorherbung lösen, aber zwei neue schaffen:

1. Du hättest 9 Bereiche mit verschiedenen Transformationen
2. Die Kurven wären optisch verzerrt.

Warum kannst Du kein Ausschnittsfenster für den inneren Bereich machen. dann wärst Du doch alle Probleme los?

Erzähl doch mal was zum Hintergrund, vielleicht ist es dann besser zu verstehen.
Zum Vergrößern anklicken....

Also die Idee der nicht homogenen Einteilungen, ein Anwendungsbeispiel wäre sogenanntes Logarithmuspaier, halte ich nicht für ganz unkritisch, da es hier vom Anwendungsfall abhängt, ob man solche "optischen Verzerrungen" wirklich haben will oder eben doch lieber homogene Einteilungen möchte. Als Anwendungsentwickler würde ich dies ohne den betroffenen User/Kunden/Anforderer zu fragen nicht selbstständig einführen.

Anbei habe ich aus meinem eigenen Fundus eine Klasse, die Skalieranforerung mittels Slider bzw. Mouse-Wheel an eine andere abstrakte JPanelklasse weitergibtmal aufgelistet.
(Solange damit kein Terroristischer Anschlag verübt wird darf mit den Sourcen was auch immer gemacht werden, und Haften tuhe ich natürlich für keinerlei Schäden ;-))

Von dieser Klasse wäre abzuleiten, wobei die Ableitung sich selbst für die Skalierung kümmern muss.
Java: 
import javax.swing.JPanel;

abstract public class ScalablePanel extends JPanel
{
	abstract public void      setScaling(double zoomFactor);
}

Diese Klasse übernimmt die Zoomanforderungen mittels Mousewheel bzw. Slider

Java: 
import java.awt.BorderLayout;
import java.awt.Dimension;
import java.awt.event.MouseWheelEvent;
import java.awt.event.MouseWheelListener;

import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JSlider;
import javax.swing.event.ChangeEvent;

/**
 * <p>Title: </p>
 * <p>Description: </p>
 * <p>Copyright: Copyright (c) 2006</p>
 * <p>Lizens: hmm... total frei: tuhe was immer Du willst damit, aber schade niemanden!</p>
 * @author Malte Kempff
 * @version 1.0
 */

public class ScalingPanel extends JPanel implements MouseWheelListener
{
    

	private BorderLayout        m_borderLayout1  = new BorderLayout();
    private JSlider             m_zoomSlider     = new JSlider();
    private JScrollPane         m_scrollPanel    = new JScrollPane();
    private ScalablePanel       m_scalablePanel;

    public ScalingPanel()
    {
        try
        {
            jbInit();
        }
        catch(Exception ex)
        {
            ex.printStackTrace();
        }
    }

    private void jbInit() throws Exception
    {
        this.setLayout(m_borderLayout1);
        m_zoomSlider.setOrientation(JSlider.VERTICAL);

        m_zoomSlider.addChangeListener(new javax.swing.event.ChangeListener()
        {
            public void stateChanged(ChangeEvent e)
            {
                zoom();
            }
        });
        this.add(m_zoomSlider, BorderLayout.WEST);
        this.add(m_scrollPanel,  BorderLayout.CENTER);
        m_zoomSlider.setMaximum(500);
        m_zoomSlider.setMinimum(5);        
    }

    public  void zoom()
    {
    	if (m_scalablePanel!=null)
    	{
    		double zoomFaktor = (double)m_zoomSlider.getValue()/(double)100;
    		m_scalablePanel.setScaling(zoomFaktor);
    		Dimension d = m_scalablePanel.getPreferredSize();
    		m_scrollPanel.getVerticalScrollBar().setMaximum(d.width);
    		m_scrollPanel.getHorizontalScrollBar().setMaximum(d.height);
    	}
//        m_scrollPanel.getVerticalScrollBar().setBlockIncrement(100);
//        m_scrollPanel.getHorizontalScrollBar().setBlockIncrement(100);
    }


    public ScalablePanel getScalablePanel()
    {
    	return m_scalablePanel;
    }

    public void setScalablePanel(ScalablePanel scalabePanel)
    {
    	if (m_scalablePanel!=null)
    	{
    		m_scalablePanel.removeMouseWheelListener(this);
    	}
    	m_scalablePanel = scalabePanel; 
    	m_scrollPanel.getViewport().add(m_scalablePanel, null);
    	
    	m_scalablePanel.addMouseWheelListener(this);
    	
    	zoom();
    }
    
    /** 
	 * @see java.awt.event.MouseWheelListener#mouseWheelMoved(java.awt.event.MouseWheelEvent)
	 */
	public void mouseWheelMoved(MouseWheelEvent e)
	{
		m_zoomSlider.setValue(m_zoomSlider.getValue()+e.getWheelRotation()*10);
		
	}
}

So würde man es z.B. anwenden, wobei natürlich SomeScalablePanel abgeleitet sein muss von ScalablePanel.
Java: 
SomeScalablePanel myScalablePanel = new SomeScalablePanel()
ScalingPanel newPane = new ScalingPanel();
newPane.setScalablePanel(myScalablePanel);

Angehängt noch 3 Screenshots von einer (noch bei mir in Entwicklung befindlichen Anwendung)
 

Anhänge

  • hardcopy2.jpg
    hardcopy2.jpg
    16,3 KB · Aufrufe: 67
  • hardcopy3.jpg
    hardcopy3.jpg
    18,1 KB · Aufrufe: 64
  • hardcopy1.jpg
    hardcopy1.jpg
    16,3 KB · Aufrufe: 52
takidoso hat gesagt.:
Also die Idee der nicht homogenen Einteilungen, ein Anwendungsbeispiel wäre sogenanntes Logarithmuspaier, halte ich nicht für ganz unkritisch, da es hier vom Anwendungsfall abhängt, ob man solche "optischen Verzerrungen" wirklich haben will oder eben doch lieber homogene Einteilungen möchte. Als Anwendungsentwickler würde ich dies ohne den betroffenen User/Kunden/Anforderer zu fragen nicht selbstständig einführen.
Zum Vergrößern anklicken....

Hi, meine Bemerkung war nicht auf Deinen Post gemünzt. Deinen Vorschlag finde ich ganz gut, er schlägt ja in meine Bresche, ein Ausschnittsfenster, oder einen zoom oder was auch immer zu machen.

So wie ich das Ganze verstehe, will Girl2005 aber keine solche Lösung. Außer irgendeiner Form von Lupe oder Zoom (die nicht alle Pixel anzeigen können) oder einer inhomogenen Skala (die verzerrt) fällt mir nichts ein. btw. die nicht homogen Einteilung muss ja nicht notwendigerweise logarithmisch sein. Klar muss Girl2005 das entscheiden, deswegen habe ich ja nochmal nach den Hintergründen gefragt.

Gruß
 
Hallo zusammen,

ich bedanke mich sehr für die anregende Diskussion.
wie limago gesgat hat, ich soll mehr zum Hintergrund erklären, damit sie mich genau verstehen.

Beispiel:
ein Benutzer eines Systems macht irgendetwas und ändert damit zwei Werte zum Beispiel Temperatur und Druck.
Die Temperatur kann Werte von 0 bis 600 haben(X-Werte)
Der Druck kann Werte zwischen -4.3 und 7.7(Y-Werte)
Der Benutzer soll jedes Mal, wenn er irgendetwas gemacht hat, die Möglichkeit im Koordinatensystem zu schauen, welche Temperatur und welchen Druck er hat oder er verursacht hat.
Das Ziel: er soll die Temperatur zwischen -5 und 5 haben, und den Druck zwischen -0.05 und 0.05 haben.
Ich glaube nicht, dass Zoomen eine gute Lösung ist.
Die Idee, die ich mich aus eueren Ideen inspiriert habe, ist...für verschiedene Bereiche verschiedene Koordinatensysteme zu erstellen. d.h wenn die Temperatur zum Beispiel beim 600 soll ein Kordinatensystem erscheinen, das inhomogen ist. Auf die X-Axe müssen in diesem Fall nicht alle Werte angezeigt werden.
Aber ich weiss nicht so genau wie ich es programmiere.
Falls ihre bessere Ideen habt, dann würde ich mich darauf freuen.
 
Mal noch 'ne Frage zu Deiner Aufgabenstellung:
Verstehe ich das richtig, dass Du einzelne Werte, also Punkte, im Koordinatensystem darstellen willst, oder musst Du ganze Kurven darstellen?

Also grob würde ich bei inhomogenen Skalen mir erstmal fragen, ob man die Skala mittels einer Formel berechenen kann, das währe z.B. bei Logarythmischen Einteilungen der Fall, oder ob man vergleichsweise willkürlich Fälle unterscheiden muss. Dies ist vermutlich bei Deinem Anwendungsfall die Situation.
Man könnte dann bei der Berechung/Ermitttlung wo der Punkt darzustellen ist, eine Routine für eine Art Skalenmapping anfragen, die im Grunde nix anderes tut, als zu unterscheiden in welchem Skalenbereich der zu malende Punkt auftritt und dann die Berchnung der richtigen Skala zugrundelegt.
In Deinem Fall scheint es so zu sein, dass Du 2 verschiedene Skalen für die X-Achse hast, deren Grenzen bei -5 und +5 sind. Der Faktor zur Skalierung den Du sonst für eine homogene Auflösung verwenden würdest, müsstest Du eigentlich dann in Abhängigkeit des X-Wertes ermitteln (bei einer starren Darstellung ohne einen Zoom) Das ganze ist im Grunde nicht viel andereres als Dreisatz mit Fallunterscheidung.

Also eine erweiterte Idee wäre, um halt nicht ein oder mehrere starre Koordinatensysteme zu bastelen, doch einen Zoom zu bauen, jedoch einen automatischen. Du musst dazu leditlich den Dir zurverfügungstehenden Raum des physschen Koordinatensystems in Bezug auf den tatsächlichen benötigten Raum setzen. Also auch wieder nix anderes Als Dreisatz (Proportionalität, Verhältnisrechung). Jedoch hast Du dann Schwellenwerte die das Koordinatensystem von einem zum anderen Zoom "umschlagen lassen".
 
Zuletzt bearbeitet:
Aber das das nicht geht ist dir schon klar oder. Die Darstelllung sollte ja linear sein sonst bringt diese ja gar nichts. Also das was du willst würde ich mit einer Lupe machen so wie vorgeschlagen.
 
alfi82 hat gesagt.:
Aber das das nicht geht ist dir schon klar oder. Die Darstelllung sollte ja linear sein sonst bringt diese ja gar nichts. Also das was du willst würde ich mit einer Lupe machen so wie vorgeschlagen.
Zum Vergrößern anklicken....

Ich bin mir nicht sicher, ob es da einen Unterschied gibt zwischen Lupe und Zoom. Sind das nicht Synonyme?
 
alfi82 hat gesagt.:
Aber das das nicht geht ist dir schon klar oder. Die Darstelllung sollte ja linear sein sonst bringt diese ja gar nichts.
Zum Vergrößern anklicken....

Wieso? Kannst Du das begründen? Das von Takidoso vorgeschlagen Verfahren mit dem Logarithmuspapier sollte wunderbar funktionieren. Das Problem ist nur, das negative Werte nicht abgebildet werden können. Diese müssten aber nur in positive Werte umgewandelt und gespiegelt werden. Das ist simpel.

Es hätte den Vorteil, das immer der gesamte Wertebereich sichtbar ist und das der Bereich kleiner Werte vergrößert abgebildet wird.

So wie das Problem dargestellt wurde, ist die dabei entstehende Verzerrung kein Problem.

Lupe und Zoom haben immer das Problem, das Teile des Wertebereichs nicht dargestellt werden können.

Gruß
 
Um antworten zu können musst du eingeloggt sein.

Neue Beiträge

Zurück