Klickbarer Bereich in einem Kreis

[Lodrik]

Mahlzeit!

Ich habe mal wieder ein kleines Problem und ich hoffe ihr könnt mir helfen.

Es geht darum, dass wir einen Jahreskreis haben (beginnend bei 12 Uhr) und darin "Termine" zeichnen sollen, der Benutzer soll Start- und Enddatum eingeben und anhand dieser 2 Werte soll der Termin dann im Kreis gezeichnet werden.

Das Zeichnen funktioniert super nur ich habe ein Problem festzustellen, ob der Mausklick auf so einem "Termin" ausgeführt wurde.

Hier der Code für die Berechnungen:

private double getAngle(double day)
{
   double dayAngle = monthGrad / daysPerMonth * day;
   double monthAngle = ((startMonth - 1) * monthGrad) + dayAngle;
   
   return mathsAngle = (-monthAngle + 90) * (Math.PI / 180.0);
}

Da wir bei 12 Uhr mit Jänner anfangen müssen, spiegel ich den Winkel und zähl danach 90° dazu damit wir immer bei 12 Uhr anfangen.

Mit diesem Winkel rechne ich mir mit Hilfe von cos und sin die An- bzw. Gegenkathete aus und rechne diese Werte zum Mittelpunkt dazu, damit ich auf den gewünschten Punkt komme.

private void calculatePoints()
{
   .....

   oppositeLeg = radius * -Math.sin(getAngle(day));
   adjaentLeg = radius * Math.cos(getAngle(day));

   points.add(new Point(center.getX() + adjaentLeg, center.getY() + oppositeLeg));
}

Jetzt zurück zu meinem Problem, ich möchte jetzt, wenn der Benutzer im Kreis auf einen "Termin" klickt, sich dieser anders einfärbt.

Ich hab mir dazu Folgendes überlegt, ich rechne mir zuerst den Abstand vom Mittelpunkt zum Mauspunkt aus und überprüfe, ob dort rein theoretisch ein "Termin" sein könnte (dass funktioniert auch ganz super) wenn diese Überprüfung, true zurückgibt schaue ich ob der Winkel vom Mauspunkt innerhalb vom Starttag Winkel und Endtag Winkel ist und genau hier hab ich Probleme.

Ich denke durch die Spiegelung und Verschiebung um 90° geht hier etwas schief. Ich hab auch schon versucht anhand des Quadranten die Vorzeichen anzupassen aber es will einfach nicht funktionieren.

Ich hoffe ihr könnt mir dabei helfen.

mfg Lodrik

 

[SlaterB]

was soll man denn dazu antworten?
wo du klickst, welche Koordinaten da rauskommem, wie die im Verhältnis zum Mittelpunkt stehen und durch deine Rechnungen dann zu was auch immer transformiert werden kann doch keiner im Kopf beurteilen,
denkbar einfach wäre es mit einem Minitestprogramm, aber du postest keins,

ansonsten könntest du dich auch rein auf die Werte konzentrieren, a la
"ich klicke auf einer Uhr gesehen etwa bei 02.45 (bisschen über ganz rechts),
der MouseListener liefert mit dann Werte ..,
daraus wird angle .., Point .., das passt nicht zu xy obwohl doch blah blah"

bisher ist das Ende gar nicht abzusehen, selbst wenn man sich selber ein Programm zusammenstricke welches die Position ausrechnet,
was ist dann die Frage?

 

[Lodrik]

Entschuldige wenn ich mich undeutlich ausgedrückt habe.

Ich hab jetzt schnell mein Problem in einem kleinen Projekt zusammengefasst.

package Test;

import java.awt.Color;
import java.awt.Graphics;
import java.awt.Point;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.util.ArrayList;
import java.util.GregorianCalendar;
import javax.swing.JPanel;


public class MyPanel extends JPanel
{
    private int margin = 15;
    private Point center;
    private int radius;
    private ArrayList<MyElement> listElement;
    private Color color;
    private boolean newElement = true;

    public MyPanel()
    {
        listElement = new ArrayList<MyElement>();
        center = new Point();

        addMouseListener(new MouseAdapter()
        {
            @Override
            public void mouseClicked(MouseEvent e)
            {
                if(newElement)
                {
                    MyElement element = new MyElement(new GregorianCalendar(2010, 2, 1), new GregorianCalendar(2010, 2, 20), radius, center);
                    listElement.add(element);

                    repaint();
                    newElement = false;
                }
                else
                {
                    checkMouseClick(e.getX(), e.getY());
                }
            }
        });
    }

    @Override
    protected void paintComponent(Graphics g)
    {
        super.paintComponent(g);
        center.setLocation(this.getWidth() / 2, this.getHeight() / 2);

        g.setColor(color);

        drawCircle(g);
        drawElements(g);
    }

    private void drawCircle(Graphics g)
    {
        if(center.getY() > center.getX())
        {
            radius = center.x - (margin * 2);
        }
        else
        {
            radius = center.y - (margin * 2);
        }

        g.drawOval(center.x - radius, center.y - radius, 2 * radius, 2 * radius);
    }

    private void drawElements(Graphics g)
    {
        for(int i = 0; i < listElement.size(); i++)
        {
            listElement.get(i).getMyElementPresentation().drawModul(g);
        }
    }

    private void checkMouseClick(int x, int y)
    {
        for(MyElement element : listElement)
        {
            if(element.getMyElementPresentation().isClicked(x, y))
            {
                color = Color.RED;
                System.out.println("Test bestanden");
                repaint();
            }
        }
    }
}

package Test;

import java.awt.Point;
import java.util.GregorianCalendar;

class MyElement
{
    private GregorianCalendar startDate;
    private GregorianCalendar endDate;
    private double duration;
    private MyElementPresentation presentation;

    public MyElement(GregorianCalendar startDate, GregorianCalendar endDate, double radius, Point center)
    {
        this.startDate = startDate;
        this.endDate = endDate;

        duration =  (endDate.getTimeInMillis() - startDate.getTimeInMillis()) / 86400000.0;

        presentation = new MyElementPresentation(radius, center, startDate, duration);
    }

    public MyElementPresentation getMyElementPresentation()
    {
        return presentation;
    }
}

package Test;

import java.awt.Graphics;
import java.awt.Point;
import java.util.Calendar;
import java.util.GregorianCalendar;

/**
 *
 * @author EveryThingEnDs
 */
class MyElementPresentation
{
    private double radius;
    private Point center;
    private double startDay;
    private double startMonth;
    private double daysPerMonth;
    private double duration;
    private double monthGrad = 30;
    private int[] xPoints;
    private int[] yPoints;

    public MyElementPresentation(double radius, Point center, GregorianCalendar startDate, double duration)
    {
        this.radius = radius;
        this.center = center;
        this.duration = duration;

       
        startDay = startDate.get(Calendar.DAY_OF_MONTH);
        startMonth = startDate.get(Calendar.MONTH);

        daysPerMonth = startDate.getActualMaximum(Calendar.DAY_OF_MONTH);

        xPoints = new int[(int) ((duration * 4) + 2)];
        yPoints = new int[(int) ((duration * 4) + 2)];

    }

    private double getAngle(double day)
    {
        double dayAngle = monthGrad / daysPerMonth * day;
        double monthAngle = ((startMonth - 1) * monthGrad) + dayAngle;

        double mathsAngle = (-monthAngle + 90);

        return mathsAngle * (Math.PI / 180.0);
    }

    private void calulatePoints()
    {
        int counter = 0;
        double angle = 0;
        double oppositeLeg = 0;
        double adjaentLeg = 0;

        for(double i = startDay; i <= startDay + duration; i += 0.5)
        {
            angle = getAngle(i);
            oppositeLeg = (radius + 5) * -Math.sin(angle);
            adjaentLeg = (radius + 5) * Math.cos(angle);

            xPoints[counter] = (int) (center.getX() + adjaentLeg);
            yPoints[counter] = (int) (center.getY() + oppositeLeg);

            counter++;
        }

        for(double j = startDay + duration; j >= startDay; j -= 0.5)
        {
            angle = getAngle(j);
            oppositeLeg = (radius - 5) * -Math.sin(angle);
            adjaentLeg = (radius - 5) * Math.cos(angle);

            xPoints[counter] = (int) (center.getX() + adjaentLeg);
            yPoints[counter] = (int) (center.getY() + oppositeLeg);

            counter++;
        }
    }

    public void drawModul(Graphics g)
    {
        calulatePoints();

        g.fillPolygon(xPoints, yPoints, xPoints.length);
    }

    public boolean isClicked(int mouseX, int mouseY)
    {
        double dx = center.x - mouseX;
        double dy = center.y - mouseY;

        double distance = Math.sqrt(Math.pow(dx, 2) + Math.pow(dy, 2));

        if((distance >= radius - 5) && (distance <= radius + 5))
        {

            //Wie Winkel berechnen?
            return true;
        }
        
        return false;
    }
}

package Test;

import java.awt.BorderLayout;
import javax.swing.JFrame;
import javax.swing.WindowConstants;

/**
 *
 * @author EveryThingEnDs
 */
public class TestFrame extends JFrame
{
    private MyPanel myPanel;

    public TestFrame()
    {
        init();
        setExtendedState(MAXIMIZED_BOTH);
    }

    private void init()
    {
        myPanel = new MyPanel();
        setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);

        setLayout(new BorderLayout());

        getContentPane().add(myPanel, BorderLayout.CENTER);

        pack();
    }

    public static void main(String args[])
    {
        java.awt.EventQueue.invokeLater(new Runnable()
        {
            public void run()
            {
                new TestFrame().setVisible(true);
            }
        });
    }
}

Wenn man das Programm startet, zeichnet er beim ersten Mausklick das Element und beim Zweiten überprüft er, ob der Mauspunkt innerhalb dieses Elements ist.

Momentan wird nur überprüft, ob die Distanz vom Mauspunkt gleich der Distanz vom Element ist (vom Mittelpunkt).
Theoretisch gibt die Methode jetzt immer true zurück, solange man auf den Kreis klickt.

Ich habe im Anhang ein Bild des Testprogrammes angehängt die das Problem (hoffentlich) veranschaulicht.

Woran ich hänge, ist die Überprüfung ob der Winkel vom Mauspunkt auch innerhalb dieses Kuchenstückes liegt.

Ich weiß es gibt die Klasse Polygon und die Methode constains ? aber wir sollen das mathematisch lösen und genau hier steck ich fest.

Ich hoffe ich habe mein Problem jetzt verständlicher machen können.

mfg Lodrik

 

[SlaterB]

nun gut, so langsam verstehe ich worum es geht, du hast ja noch überhaupt keine Umkehrberechnungen


zwischen dem Zentrum und dem Mausklick gibt es eine Linie, diese bildet mit den senkrechen und waagerechten Achsen ein rechtwinkliges Dreieck,
deren beiden kürzeren Seiten du kennst, sowie nach Satz des Pythagoras auch die länge, Hypotenuse & Co,
von den Dingen hast du sicher schon gehört?

sin(winkel) = irgeneine Seite/ Hypotenuse
->
winkel = asin(irgendeine Seite/ Hypotenuse)

die Methode Math.asin() gibt es, damit bekommst du einen Winkel im Bogenmaß, schnell in Grad umgerechnet, falls benötigt,
dann muss man noch auf 0-360 Grad oder 0 bis 2PI erweitern, durch dx und dy bestimmen ob 90 oder 180 draufzuaddieren ist oder abzuziehen usw.,
erstmal Testwerte, erstmal nur oben rechts passend machen, nach und nach dann überall,
tja und zu deinen Elementen musst du den Winkelbereich irgendwo abspeichern und vergleichen,

du hast Recht dass "durch die Spiegelung und Verschiebung um 90°" viel zu tun ist, aber noch hast du ja gar keine Berechnung,
da kann ich auch nix korrigieren

-----

noch ein Hinweis: beim Java-Calendar gibt man die Monate mit 0-11 an, dann brauchst du das -1 nicht in der angle-Berechnung,
bisher kommt alles hin, aber Dezember 12 würde wohl nicht so gut aussehen

 

[Lodrik]

Danke für deine Hilfe!

Ich hatte es schon mal versucht aber ich bin nie auf einen grünen Zweig gekommen.

Nichtsdestotrotz, ich hab mir deine Antwort durchgelesen und versucht das Ganze so umzusetzen, mit folgendem Ergebnis:

public boolean isClicked(int mouseX, int mouseY)
    {
        double dx = center.x - mouseX;
        double dy = center.y - mouseY;

        double distance = Math.sqrt(Math.pow(dx, 2) + Math.pow(dy, 2));

        if((distance >= radius - 5) && (distance <= radius + 5))
        {
            double mouseAngle = Math.toDegrees(Math.atan(dx / dy));

            double firstAngle = Math.toDegrees(Math.atan((center.getX() - xPoints[0]) / (center.getY() - yPoints[0])));
            double secondAngle = Math.toDegrees(Math.atan((center.getX() - xPoints[xPoints. length / 2 - 1]) / (center.getY() - yPoints[yPoints.length / 2 - 1])));

            System.out.println(mouseAngle + "  " + firstAngle + "   " + secondAngle);

            if((dx < 0) && (dy > 0))
            {
                mouseAngle += 90;
                firstAngle += 90;
                secondAngle += 90;
            }

            if((dx < 0) && (dy < 0))
            {
                mouseAngle += 180;
                firstAngle += 180;
                secondAngle += 180;
            }


            if((mouseAngle <= firstAngle) && (mouseAngle >= secondAngle))
            {
                return true;
            }
        }

        return false;
    }

Ich habe es kurz in allen 4 Quadranten versucht und es scheint zu funktionieren. Habe ich irgendwas vergessen oder gibt es noch etwas zu beachten?

mfg Lodrik

 

[Lodrik]

Ich hab es nun mit ein paar Testdaten nochmals versucht und es scheint reibungslos zu funktionieren.

Danke für deine Hilfe SlaterB.

mfg Lodrik

 

[Lodrik]

Ok, es gibt doch noch ein Problem

Was ich vorher nicht berücksichtigt hab, was ist, wenn ein Termin sich über mehr als einen Quadranten erstreckt?

Hier scheint die Rechnung noch Fehler zu haben.

Kann mir vl bitte jemand einen Tipp geben, wie ich das berücksichtigen kann bzw. was ich an meiner Rechnung ändern muss?

mfg Lodrik

 

[SlaterB]

firstAngle und secondAngle musst du einmalig ausrechnen, in MyElementPresentation

> for(double i = startDay; i <= startDay + duration; i += 0.5)
> {
> angle = getAngle(i);

getAngle(startDay) ist der erste Winkel, der zweite entsprechend, ohne irgendwelche Verschiebung, jedenfalls nicht abhängig von Mausklicks

 

[Lodrik]

Danke für deine schnelle Antwort.

sollte der 2. Winkel dann nicht getAngle(startDay + duration) sein?

Ich hab es jetzt versucht (der 2. Winkel ist getAngle(startDay + duration)), dann funktioniert das ganze genau in einem Quadranten. Muss ich bei den Winkel auch noch schauen in welchem Quadranten sie liegen?

 

[SlaterB]

> sollte der 2. Winkel dann nicht getAngle(startDay + duration) sein?

was sonst? ich schrieb 'entsprechend', da kannst du nicht draus lesen

-----

> Muss ich bei den Winkel auch noch schauen in welchem Quadranten sie liegen?

du musst nur denken und testen, die Berechnung von angle() kann natürlich noch nicht perfekt sein, aber wenn dann ist das doch leicht festzustellen,
in welchen Quadranten was wo liegt spielt keine Rolle sofern alles richtig gerechnet wird,
mache dir ein Beispiel Februar bis November, wenn das 20 bis 340 Grad belegt, dann ist das schon gut, völlig gleich wie du dahin kommst,
mir schien, dass die Tage + Monate-Berechnung ganz gut den Bereich bis 360 Grad abdeckte

und zu jedem Mausklick muss genau ein Winkel berechnet werden, ob 5, 25, 75, 275 oder 359 Grad, der muss da sein ganz unabhängig von irgendwelchen Terminen,
wenn er dann berechnet ist, nur noch mit Min/ Max der (evtl. mehreren) Terminen vergleichen

 

[Lodrik]

Ok, ich habe gerade gesehen, dass die Berechnung anscheinend noch fehleranfällig ist.

Gibt man einen Zeitraum von Anfang Februar bis Ende November ein, wird der Termin in den Dezember Bereich gezeichnet.
Gibt man aber nur Anfang November bis Ende November ein, stimmt die Zeichnung.

Hier muss ich wohl noch auf Fehler suche gehen.

Ich hab jetzt noch eine Frage bezüglich den Graden in dem Kreis. Ich hab mir den Winkel an den 4 Achsenstellen ausgerechnet und bei mir kommt (im Uhrzeigersinn) 0°, 90°, -0° und -90° raus. Stimmt das so? Ich steh momentan komplett auf dem Schlauch.

Entschuldige, das muss sicher anstrengend sein mit mir.

mfg Lodrik

 

[Lodrik]

Ich bins mal wieder

Ich hab jetzt versucht die getAngle() Methode umzuschreiben bzw. den Fehler auszubessern.

Ich hab mir Folgendes gedacht:

Ich speicher mir, wenn ich ein neues Element erzeuge, im Konstruktor das übergebene "startDate" in einem "actualDate" und "oldDate", ich speicher ebenfalls den "startMonth" und die "daysPerMonth".

In der Methode selbst rechne ich zuerst den Winkel aus, und überprüfe danach ob oldDate und actualDate gleich sind, wenn nicht speicher ich actualDate auf oldDate, setz den startDay auf 0 und rechne mir noch die "daysPerMonth" aus. Wenn sie gleich sind, erhöhe ich den actualDay um 0.5 (ich würde gerne 2 punkte / Tag ausrechnen).

Damit die Abfrage auch funktioniert, muss ich "actualDate" erhöhen, ich kann aber schlecht einen halben Tag dazu rechnen.

Die Methode schaut momentan so aus:

        double dayAngle = monthGrad / daysPerMonth * actualDay;
        double monthAngle = ((startMonth) * monthGrad) + dayAngle;

        double mathsAngle = (-monthAngle + 90);

        if(state)
        {
            if(oldDate.get(Calendar.MONTH) != actualDate.get(Calendar.MONTH))
            {
                oldDate = actualDate;
                actualDay = 0;
                daysPerMonth = actualDate.getActualMaximum(Calendar.DAY_OF_MONTH);
                startMonth = actualDate.get(Calendar.MONTH);
            }
            else
            {               
                actualDay += 0.5;
                //Hier sollte das actualDate noch erhöht werden.
            }
        }

        if(!state)
        {
            if(oldDate.get(Calendar.MONTH) != actualDate.get(Calendar.MONTH))
            {
                oldDate = actualDate;
                actualDay = actualDate.getActualMaximum(Calendar.DAY_OF_MONTH) - 1;
                daysPerMonth = actualDate.getActualMaximum(Calendar.DAY_OF_MONTH);
                startMonth = actualDate.get(Calendar.MONTH);
            }
            else
            {
                actualDay -= 0.5;
                //Hier sollte noch das actualDate erhöht werden.
            }
        }

        return mathsAngle * (Math.PI / 180.0);

"state" gibt mir darüber Auskunft ob ich in der Schleife vom Start bis zum Ende rechne oder vom Ende bis zum Start.
Kann mir vl jemand eine Tipp geben wie ich das anders lösen könnte bzw. wie ich das mit dem actualDay lösen könnte?

Vielen Dank für eure Geduld mit mir ^^

mfg Lodrik

 

[SlaterB]

public class Test
{
    public static void main(String args[])
    {
        java.awt.EventQueue.invokeLater(new Runnable()
            {
                public void run()
                {
                    new TestFrame().setVisible(true);
                }
            });
    }
}


class TestFrame
    extends JFrame
{
    public TestFrame()
    {
        MyPanel myPanel = new MyPanel();
        setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
        getContentPane().add(myPanel, BorderLayout.CENTER);
        setSize(300, 300);
    }
}


class MyPanel
    extends JPanel
{
    private int margin = 15;
    private Point center;
    private int radius;
    private ArrayList<MyElement> listElement;
    private Color color;
    private boolean newElement = true;

    public MyPanel()
    {
        listElement = new ArrayList<MyElement>();
        center = new Point();

        addMouseListener(new MouseAdapter()
            {
                @Override
                public void mouseClicked(MouseEvent e)
                {
                    if (newElement)
                    {
                        MyElement element = new MyElement(new GregorianCalendar(2010, 2, 1), new GregorianCalendar(2010, 2, 20),
                                                          radius, center);
                        listElement.add(element);
                        element = new MyElement(new GregorianCalendar(2010, 3, 1), new GregorianCalendar(2010, 3, 20), radius,
                                                center);
                        listElement.add(element);
                        element = new MyElement(new GregorianCalendar(2010, 4, 1), new GregorianCalendar(2010, 9, 20), radius,
                                                center);
                        listElement.add(element);

                        repaint();
                        newElement = false;
                    }
                    else
                    {
                        checkMouseClick(e.getX(), e.getY());
                    }
                }
            });
    }

    @Override
    protected void paintComponent(Graphics g)
    {
        super.paintComponent(g);
        center.setLocation(this.getWidth() / 2, this.getHeight() / 2);

        g.setColor(color);

        drawCircle(g);
        drawElements(g);
    }

    private void drawCircle(Graphics g)
    {
        if (center.getY() > center.getX())
        {
            radius = center.x - (margin * 2);
        }
        else
        {
            radius = center.y - (margin * 2);
        }

        g.drawOval(center.x - radius, center.y - radius, 2 * radius, 2 * radius);
    }

    private void drawElements(Graphics g)
    {
        for (int i = 0; i < listElement.size(); i++)
        {
            listElement.get(i).getMyElementPresentation().drawModul(g);
        }
    }

    private void checkMouseClick(int x, int y)
    {
        System.out.println("checkMouseClick");
        double dx = center.x - x;
        double dy = center.y - y;

        double distance = Math.sqrt(Math.pow(dx, 2) + Math.pow(dy, 2));

        double mouseAngle = -2000;
        if (distance <= radius)
        {
            mouseAngle = Math.toDegrees(Math.atan(dx / dy));
            System.out.println("mouseAngle1: " + mouseAngle);

            if (dy < 0)
            {
                mouseAngle = 180 - mouseAngle;
            }
            else
            {
                if (dx < 0)
                {
                    mouseAngle = -mouseAngle;
                }
                else
                {
                    mouseAngle = 360 - mouseAngle;
                }
            }


            System.out.println("mouseAngle2: " + mouseAngle);
        }

        for (MyElement element : listElement)
        {
            element.getMyElementPresentation().checkClicked(mouseAngle);
        }
        repaint();
    }
}


class MyElementPresentation
{
    private double radius;
    private Point center;
    private double firstAngle;
    private double lastAngle;
    private double startDay;
    private double startMonth;
    private double daysPerMonth;
    private double duration;
    private double monthGrad = 30;
    private int[] xPoints;
    private int[] yPoints;
    public Color color = Color.BLACK;

    public MyElementPresentation(double radius, Point center, GregorianCalendar startDate, double duration)
    {
        this.radius = radius;
        this.center = center;
        this.duration = duration;


        startDay = startDate.get(Calendar.DAY_OF_MONTH);
        startMonth = startDate.get(Calendar.MONTH);

        daysPerMonth = startDate.getActualMaximum(Calendar.DAY_OF_MONTH);

        xPoints = new int[(int)((duration * 4) + 2)];
        yPoints = new int[(int)((duration * 4) + 2)];

    }

    private double getAngle(double day)
    {
        double mathsAngle = (-getAngle2(day) + 90);
        return mathsAngle * (Math.PI / 180.0);
    }

    private double getAngle2(double day)
    {
        double dayAngle = monthGrad / daysPerMonth * day;
        double monthAngle = ((startMonth - 1) * monthGrad) + dayAngle;
        return monthAngle;
    }

    private void calulatePoints()
    {
        firstAngle = getAngle2(startDay);
        lastAngle = getAngle2(startDay + duration);
        int counter = 0;
        double angle = 0;
        double oppositeLeg = 0;
        double adjaentLeg = 0;

        for (double i = startDay; i <= startDay + duration; i += 0.5)
        {
            angle = getAngle(i);
            oppositeLeg = (radius + 5) * -Math.sin(angle);
            adjaentLeg = (radius + 5) * Math.cos(angle);

            xPoints[counter] = (int)(center.getX() + adjaentLeg);
            yPoints[counter] = (int)(center.getY() + oppositeLeg);

            counter++;
        }

        for (double j = startDay + duration; j >= startDay; j -= 0.5)
        {
            angle = getAngle(j);
            oppositeLeg = (radius - 5) * -Math.sin(angle);
            adjaentLeg = (radius - 5) * Math.cos(angle);

            xPoints[counter] = (int)(center.getX() + adjaentLeg);
            yPoints[counter] = (int)(center.getY() + oppositeLeg);

            counter++;
        }
    }

    public void drawModul(Graphics g)
    {
        calulatePoints();
        g.setColor(color);
        g.fillPolygon(xPoints, yPoints, xPoints.length);
    }

    public void checkClicked(double angle)
    {
        System.out.println("check clicked: " + angle + ", " + firstAngle + ", " + lastAngle);
        if (angle > firstAngle && angle < lastAngle)
        {
            color = Color.RED;
        }
        else if (angle > firstAngle)
        {
            color = Color.BLUE;
        }
        else
        {
            color = Color.ORANGE;
        }
    }
}


class MyElement
{
    private GregorianCalendar startDate;
    private GregorianCalendar endDate;
    private double duration;
    private MyElementPresentation presentation;

    public MyElement(GregorianCalendar startDate, GregorianCalendar endDate, double radius, Point center)
    {
        this.startDate = startDate;
        this.endDate = endDate;
        duration = (endDate.getTimeInMillis() - startDate.getTimeInMillis()) / 86400000.0;
        presentation = new MyElementPresentation(radius, center, startDate, duration);
    }

    public MyElementPresentation getMyElementPresentation()
    {
        return presentation;
    }
}

 

[Lodrik]

Wahnsinn Vielen Dank das funktioniert Super!

Danke für deine Geduld!

Jetzt noch den Feinschliff in die Winkelberechnung bringen und dann ist das ganze perfekt.

Vielen Dank nochmal für deine Hilfe!

mfg Lodrik