Triangle Intercept Theorem -

Question

import java.awt.BorderLayout;
import java.awt.CardLayout;
import java.awt.Dimension;
import java.awt.event.MouseEvent;
import java.awt.event.MouseMotionListener;
import javax.swing.JFrame;
import javax.swing.JPanel;
public class G {
    CardLayout cards;
    JPanel panel;
    public G() {
        cards = new CardLayout();
        panel = new JPanel(cards);
        addCards();
        JFrame f = new JFrame("Geometry");
        f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        f.getContentPane().add(panel);
        Dimension screenSize = java.awt.Toolkit.getDefaultToolkit().getScreenSize();
        f.setSize(screenSize);
        f.setLocation(0,0);
        f.setVisible(true);
        f.addMouseMotionListener(
        new MouseMotionListener() { //anonymous inner class
            //handle mouse drag event
            public void mouseMoved(MouseEvent e) {
                System.out.println("Mouse  " + e.getX() +","  + e.getY());
            public void mouseDragged(MouseEvent e) {
                System.out.println("Draggg: x=" + e.getX() + "; y=" + e.getY());
    private void addCards() {
        // card THREE
        //{211,100},{124,150},{298,150}}, new int[][] {{422,200},{248,300},{596,300}
        InterceptModel trin1 = new InterceptModel(new int[][] {{300,100},{250,146},{594,146}}, new int[][] {{300,100},{138,300},{440,300}});
        InterceptView view1  = new InterceptView(trin1);
        JPanel panelThree = new JPanel(new BorderLayout());
        panelThree.add(view1.getUIPanel(), "North");
        // panelTwo.setBackground(Color.blue);
        panelThree.setName("Intercept Theorem");
        panelThree.add(view1);
        //panelThree.add(view1.getInterceptTablePanelA(), "East");
        //JPanel rightPanel1 = new JPanel();
        //rightPanel1.add(view1.getTxtPanel());
        //panelThree.add(rightPanel1, "South");
        panelThree.add(view1.getInterceptTablePanel(),"South");
        view1.addMouseMotionListener(
        new MouseMotionListener() { //anonymous inner class
            //handle mouse drag event
            public void mouseMoved(MouseEvent e) {
                System.out.println("Mouse at " + e.getX() +","  + e.getY());
            public void mouseDragged(MouseEvent e) {
                System.out.println("Dragging: x=" + e.getX() + "; y=" + e.getY());
        panel.add("Intercept Theorem", panelThree);
       private void ExitActionPerformed(java.awt.event.ActionEvent evt) {
        // TODO add your handling code here:
        System.exit(0);
    public static void main(String[] args) {
        new G();
import java.awt.*;
import java.awt.event.*;
import java.awt.geom.*;
import java.text.NumberFormat;
import javax.swing.*;
import javax.swing.event.*;
import javax.swing.table.DefaultTableCellRenderer;
* @author  Sharan Bhojwani
public class InterceptModel {
                                                  //      |\
    static final int SIDES = 3;                //      | \
    private int cx, cy;                        //      |  \
    Polygon smallTriangle;
    Polygon bigTriangle;                       //      |_ _\ (x3, y3)
    int selectedIndex;                         //  (x2, y2)
    NumberFormat nf;
    Line2D[] medians;
    Point2D centroid;
    // The ratio of scaling, NOT size
    // i.e. the ratio of scaling can be 2 and yet the triangles the same size
    int ratio;
    /** Creates a new instance of InterceptModel */
    public InterceptModel(int[][] triangleOne, int[][] triangleTwo)
        // make first triangle
        int[] x = new int[] { triangleOne[0][0], triangleOne[1][0], triangleOne[2][0] };
        int[] y = new int[] {triangleOne[0][1], triangleOne[1][1], triangleOne[2][1] };
        smallTriangle = new Polygon(x, y, SIDES);
        // make second triangle
        int[] x2 = new int[] { triangleTwo[0][0], triangleTwo[1][0], triangleTwo[2][0] };
        int[] y2 = new int[] {triangleTwo[0][1], triangleTwo[1][1], triangleTwo[2][1] };
        bigTriangle = new Polygon(x2,y2,SIDES);
        nf = NumberFormat.getNumberInstance();
        nf.setMaximumFractionDigits(1);
        ratio=3;
    public void setRatio(int ratio) {
        this.ratio = ratio;
        sizeTriangles();
    public int getRatio() {
        return ratio;
    // this sets the size of the triangles once the ratio has been changed
    // ratio is side of smaller triangle AB in 100's of pixels
    void sizeTriangles() {
        //work out x & y ratios
        int xleftSmall = (int) (ratio*100 * Math.sin(30));
        int yleftSmall = (int) (ratio*100 * Math.cos(30));
        int yrightSmall = yleftSmall;
        int xrightSmall = (int) (yleftSmall * Math.tan(40));
        int xSmall[] = {300,300-xleftSmall,300+xrightSmall};
        int ySmall[] = {100,100+yleftSmall,100+yrightSmall};
        smallTriangle.xpoints = xSmall;
        smallTriangle.ypoints = ySmall;
        int bigRatio = ratio*100*2;
        //work out x & y ratios
        int xleftBig = (int) (bigRatio * Math.sin(30));
        int yleftBig = (int) (bigRatio * Math.cos(30));
        int yrightBig = yleftBig;
        int xrightBig = (int) (yleftBig * Math.tan(40));
        int xBig[] = {300,300-xleftBig,300+xrightBig};
        int yBig[] = {100,100+yleftBig,100+yrightBig};
        bigTriangle.xpoints = xBig;
        bigTriangle.ypoints = yBig;
        System.out.println("changed sizes");
       // take x0,y0 of big
       int[] x = (int[]) bigTriangle.xpoints.clone();
       int[] y = (int[]) bigTriangle.ypoints.clone();
       // bring bigTriangle points to 0,0 to make things easier
       for (int i=SIDES-1; i>-1; i--) {
           x[i] = x[i] - x[0];
           y[i] = y[i] - y[0];
       // resize to make small triangle points
       for (int i=0; i<SIDES; i++) {
           x[i] = x[i] / ratio;
           y[i] = y[i] / ratio;
       // translate to fit onto the pane
       for (int i=0; i<SIDES; i++) {
           x[i] = x[i] + 213;
           y[i] = y[i] + 125;
       smallTriangle.xpoints = x;
       smallTriangle.ypoints = y;
        public boolean contains(Point p, Polygon triangle)
        // Polygon.contains doesn't work well enough
        return (new Area(triangle)).contains(p);
    public boolean isLineSelected(Rectangle r)
        Line2D line = new Line2D.Double();
        for(int j = 0; j < SIDES; j++)
            int[] x = smallTriangle.xpoints;
            int[] y = smallTriangle.ypoints;
            int x1 = x[j];
            int y1 = y[j];
            int x2 = x[(j + 1) % SIDES];
            int y2 = y[(j + 1) % SIDES];
            line.setLine(x1, y1, x2, y2);
            if(line.intersects(r))
                selectedIndex = j;
                return true;
        selectedIndex = -1;
        return false;
    public void moveSide(int dx, int dy, Point p)
        int[] x = smallTriangle.xpoints;
        int[] y = smallTriangle.ypoints;
        int[] x1 = bigTriangle.xpoints;
        int[] y1 = bigTriangle.ypoints;
        switch(selectedIndex)
            case 0:
                double length =  Math.sqrt((x[1]-x[0])*(x[1]-x[0]) + (y[1]-y[0])*(y[1]-y[0]));
                int xpoint = x[1] + dx;
                int ypoint = y[1] + dy;
                double newlength = Math.sqrt((xpoint-x[0])*(xpoint-x[0]) + (ypoint-y[0])*(ypoint-y[0]));
                double scale = length/newlength;
                x[1] = new Double(p.x*scale).intValue();
                y[1] = new Double(p.y*scale).intValue();
                int px_forBig = ((p.x - x[0])*ratio) + x1[0];
                int py_forBig = ((p.y - y[0])*ratio) + y1[0];
                x1[1] = new Double( px_forBig  * scale).intValue();
                y1[1] = new Double( py_forBig  * scale).intValue();
                break;
            case 1:
                length =  Math.sqrt((x[2]-x[1])*(x[2]-x[1]) + (y[2]-y[1])*(y[2]-y[1]));
                xpoint = x[2] + dx;
                ypoint = y[2] + dy;
                newlength = Math.sqrt((xpoint-x[1])*(xpoint-x[1]) + (ypoint-y[1])*(ypoint-y[1]));
                scale = length/newlength;
                x[2] = new Double(p.x*scale).intValue();
                y[2] = new Double(p.y*scale).intValue();
                px_forBig = ((p.x - x[1])*ratio) + x1[1];
                py_forBig = ((p.y - y[1])*ratio) + y1[1];
                x1[2] = new Double( px_forBig  * scale).intValue();
                y1[2] = new Double( py_forBig  * scale).intValue();
                break;
            case 2:
  length =  Math.sqrt((x[0]-x[2])*(x[0]-x[2]) + (y[0]-y[2])*(y[0]-y[2]));
                xpoint = x[0] + dx;
                ypoint = y[0] + dy;
                newlength = Math.sqrt((xpoint-x[2])*(xpoint-x[2]) + (ypoint-y[2])*(ypoint-y[2]));
                scale = length/newlength;
                x[0] = new Double(p.x*scale).intValue();
                y[0] = new Double(p.y*scale).intValue();
                px_forBig = ((p.x - x[2])*ratio) + x1[2];
                py_forBig = ((p.y - y[2])*ratio) + y1[2];
                x1[0] = new Double( px_forBig  * scale).intValue();
                y1[0] = new Double( py_forBig  * scale).intValue();
    public void translate(int dx, int dy, Polygon triangle)
        triangle.translate(dx, dy);
    public Polygon getSmallTriangle()
        return smallTriangle;
    public Polygon getBigTriangle()
        return bigTriangle;
    public String findCentroid(Polygon triangle)
        int[] x = triangle.xpoints;
        int[] y = triangle.ypoints;
        // construct the medians defined as the line from
        // any vertex to the midpoint of the opposite line
        medians = new Line2D[x.length];
        for(int j = 0; j < x.length; j++)
            int next = (j + 1) % x.length;
            int last = (j + 2) % x.length;
            Point2D vertex = new Point2D.Double(x[j], y[j]);
            // get midpoint of line opposite vertex
            double dx = ((double)x[last] - x[next])/2;
            double dy = ((double)y[last] - y[next])/2;
            Point2D oppLineCenter = new Point2D.Double(x[next] + dx,
                                                       y[next] + dy);
            medians[j] = new Line2D.Double(vertex, oppLineCenter);
        // centroid is located on any median 2/3 the way from the
        // vertex (P1) to the midpoint (P2) on the opposite side
        double[] lengths = getSideLengths(triangle);
        double dx = (medians[0].getX2() - medians[0].getX1())*2/3;
        double dy = (medians[0].getY2() - medians[0].getY1())*2/3;
        double px = medians[0].getX1() + dx;
        double py = medians[0].getY1() + dy;
        //System.out.println("px = " + nf.format(px) +
        //                 "\tpy = " + nf.format(py));
        centroid = new Point2D.Double(px, py);
        return "(" + nf.format(px) + ",  " + nf.format(py) + ")";
    public String[] getAngles(Polygon triangle)
        double[] lengths = getSideLengths(triangle);
        String[] vertices = new String[lengths.length];
        for(int j = 0; j < lengths.length; j++)
            int opp  = (j + 1) % lengths.length;
            int last = (j + 2) % lengths.length;
            double top = lengths[j] * lengths[j] +
                         lengths[last] * lengths[last] -
                         lengths[opp] * lengths[opp];
            double divisor = 2 * lengths[j] * lengths[last];
            double vertex = Math.acos(top / divisor);
            vertices[j] = nf.format(Math.toDegrees(vertex));
        return vertices;
    public String[] getLengths(Polygon triangle)
        double[] lengths = getSideLengths(triangle);
        String[] lengthStrs = new String[lengths.length];
        for(int j = 0; j < lengthStrs.length; j++){
            lengthStrs[j] = nf.format(lengths[j]);
        return lengthStrs;
    public double[] getSideLengths(Polygon triangle)
        int[] x = triangle.xpoints;
        int[] y = triangle.ypoints;
        double[] lengths = new double[SIDES];
        for(int j = 0; j < SIDES; j++)
            int next = (j + 1) % SIDES;
            lengths[j] = Point.distance(x[j], y[j], x[next], y[next]);
        return lengths;
import java.awt.*;
import java.awt.event.*;
import java.awt.font.FontRenderContext;
import java.awt.font.LineMetrics;
import java.awt.geom.*;
import java.text.NumberFormat;
import javax.swing.*;
import javax.swing.event.*;
import javax.swing.table.DefaultTableCellRenderer;
* @author  Sharan Bhojwani
public class InterceptView extends JPanel {
    public InterceptModel model;
    public Polygon smallTriangle;
    public Polygon bigTriangle;
    private JTable intercepttable;
    private JTable interceptTableA;
    private JTable interceptTableB;
    public JLabel centroidLabel;
    Font sideFont, vertexFont, areaFont;
    private boolean showConstruction;
    private InterceptControl interceptcontrol;
    private NumberFormat nf;
    JLabel ratLabel;
    JSlider ratSlider;
    final int ABCLABELS = 0;
    final int DEFLABELS = 1;
    JTextArea tarea2;
    final int abclabels = 0;
    final int deflabels = 1;
    final String notes[] = {
        // note 0
        "HELLOO "  ,
    public InterceptView(InterceptModel model) {
        this.model = model;
        smallTriangle = model.getSmallTriangle();
        bigTriangle = model.getBigTriangle();
        showConstruction = false;
        interceptcontrol= new InterceptControl(this);
        addMouseListener(interceptcontrol);
        addMouseMotionListener(interceptcontrol);
        sideFont = new Font("times new roman", Font.PLAIN, 14);
        vertexFont = new Font("lucida sans demibold", Font.PLAIN, 18);
        areaFont = vertexFont.deriveFont(12f);
        nf = NumberFormat.getNumberInstance();
        nf.setMaximumFractionDigits(1);
    public void paintComponent(Graphics g) {
        super.paintComponent(g);
        Graphics2D g2 = (Graphics2D)g;
        g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
        RenderingHints.VALUE_ANTIALIAS_ON);
        g2.draw(smallTriangle);
        g2.draw(bigTriangle);
        labelTriangle(g2, smallTriangle, this.ABCLABELS);
        labelTriangle(g2, bigTriangle, this.DEFLABELS);
        //if(model.medians == null)
        //    centroidLabel.setText("centroid location: " + model.findCentroid(smallTriangle));
        // draw medians and centroid point
        if(showConstruction && !interceptcontrol.dragging) {
            g2.setPaint(Color.red);
            for(int j = 0; j < 3; j++)
                //                g2.draw(model.medians[j]);
                g2.setPaint(Color.blue);
            //            g2.fill(new Ellipse2D.Double(model.centroid.getX() - 2,
            //                                         model.centroid.getY() - 2, 4, 4));
    private void labelTriangle(Graphics2D g2, Polygon triangle, int labelSet) {
        // sides
        // adjacent - c
        int PAD = 10;
        g2.setFont(sideFont);
        FontRenderContext frc = g2.getFontRenderContext();
        int[] x = triangle.xpoints;
        int[] y = triangle.ypoints;
        double[] lengths = model.getSideLengths(triangle);
        double theta = -computeAngle(lengths[0], lengths[1], lengths[2]);
        // vertices
        g2.setFont(vertexFont);
        frc = g2.getFontRenderContext();
        // A
        theta = -Math.PI/2 - computeAngle(lengths[0], lengths[1], lengths[2])/2;
        int cx = x[0] + (int)((2 * PAD) * Math.cos(theta));
        int cy = y[0] + (int)((2 * PAD) * Math.sin(theta));
        float w = (float)vertexFont.getStringBounds("A", frc).getWidth();
        LineMetrics lm = vertexFont.getLineMetrics("A", frc);
        float h = lm.getAscent();
        float sx = cx - w/2 +15 ;
        float sy = cy + h/2;
        if (labelSet == 0) {
            g2.drawString("A", sx, sy); }
        //        else if (labelSet == 1) {
        //            g2.drawString("D", sx, sy); }
        // C
        theta = Math.PI*3/4;
        cx = x[1] + (int)((2 * PAD) * Math.cos(theta));
        cy = y[1] + (int)((2 * PAD) * Math.sin(theta));
        w = (float)vertexFont.getStringBounds("C", frc).getWidth();
        lm = vertexFont.getLineMetrics("C", frc);
        h = lm.getAscent();
        sx = cx - w/2 + 2;///2;
        sy = cy - h/2 -4 ;
        if (labelSet == 0) {
            g2.drawString("C", sx, sy); }
//        else if (labelSet == 1) {
//            g2.drawString("E", sx, sy); }
        // C//E
        theta = computeAngle(lengths[2], lengths[0], lengths[1])/2;
        cx = x[2] + (int)((2 * PAD) * Math.cos(theta));
        cy = y[2] + (int)((2 * PAD) * Math.sin(theta));
        w = (float)vertexFont.getStringBounds("B", frc).getWidth();
        lm = vertexFont.getLineMetrics("B", frc);
        h = lm.getAscent();
        sx = cx - w   ;
        sy = cy - h/2  ;
        if (labelSet == 0) {
            g2.drawString("B", sx, sy); }
//        else  if (labelSet == 1) {
//            g2.drawString("D", sx, sy);
    private double computeAngle(double side, double opp, double last) {
        double top = side * side + last * last - opp * opp;
        double divisor = 2 * side * last;
        return Math.acos(top / divisor);
    public InterceptModel getModel() {
        return model;
    public JTable getInterceptTableA() {
        return interceptTableA;
    public JTable getInterceptTable(){
    return intercepttable;
    public JTable getInterceptTableB() {
        return interceptTableB;
    public JLabel getCentroidLabel() {
        return centroidLabel;
    public JPanel getUIPanel() {
        ratSlider = new JSlider(0,5,4);
        ratSlider.setPaintTicks(true);
        ratLabel = new JLabel("AB = BD = " + (5 * ratSlider.getValue()));
        ratSlider.addChangeListener(new ChangeListener() {
            public void stateChanged(ChangeEvent e) {
                ratLabel.setText("AB = BD = " + (5* ratSlider.getValue()));
                interceptcontrol.setRatio(ratSlider.getValue());
                //boolean state = ((JCheckBox)e.getSource()).isSelected();
                //showConstruction = state;
                repaint();
        JPanel panel = new JPanel();
        panel.add(ratSlider);
        panel.add(ratLabel);
        return panel;
    public JPanel getInterceptTablePanel(){
      String[] headers = new String[] { "", "", "", "" ,"",""};
        String[] rowHeaders = {
            "Sides","Lengths","Ratio","RatioValues",""
        String[] sidesRow = new String[]{"AB","AC","BC","BD","CE","DE"};
        //String[] anglesRow = { "^BAC", "^DBC", "^BCE","^BDE", "^DEC" };
        String[] sidesRatio = new String[] {"AB/BD", "", "AC/CE","","BC/CE"};
        //String[] angles  = model.getAngles(smallTriangle);
        String[] lengthsSmallTriangle = model.getLengths(smallTriangle);
        double[] doLengthsBigTri = model.getSideLengths(bigTriangle);
        double[] doLengthsSmaTri = model.getSideLengths(smallTriangle);
        int BD = (int) (doLengthsBigTri[0] - doLengthsSmaTri[0]);
        int CE = (int) (doLengthsBigTri[2] - doLengthsSmaTri[2]);
        String[] lengths = {lengthsSmallTriangle[0],lengthsSmallTriangle[2],lengthsSmallTriangle[1],
            nf.format(BD), nf.format(CE), nf.format(doLengthsBigTri[1])};
        String[] ratios = {nf.format(doLengthsSmaTri[0]/BD),"", nf.format(doLengthsSmaTri[2]/CE), "", nf.format(doLengthsSmaTri[1]/doLengthsBigTri[1])};
        String[][] allData = { sidesRow, lengths, sidesRatio, ratios };
        int rows = 4;
        int cols = 6;
        Object[][] data = new Object[rows][cols];
        for(int row = 0; row < rows; row++) {
            data[row][0] = rowHeaders[row];
            for(int col = 1; col < cols; col++)
                data[row][col] = allData[row][col - 1];
         intercepttable = new JTable(data, headers) {
            public boolean isCellEditable(int row, int col) {
                return false;
        DefaultTableCellRenderer renderer =
        (DefaultTableCellRenderer)intercepttable.getDefaultRenderer(String.class);
        renderer.setHorizontalAlignment(JLabel.CENTER);
        JPanel panel = new JPanel();
        panel.add(intercepttable);
        return panel;
    public JPanel getInterceptTablePanelB() {
        String[] headers = new String[] { "", "", "", "" };
        // row and column data labels
        String[] rowHeaders = {
            "sides", "lengths", "angles", "degrees"
        String[] sidesRow = { "D-E", "E-F", "F-D" };
        String[] anglesRow = { "Angle D", "Angle E", "Angle F" };
        // collect data from model
        String[] angles  = model.getAngles(smallTriangle);
        String[] lengths = model.getLengths(smallTriangle);
        String[][] allData = { sidesRow, lengths, anglesRow, angles };
        int rows = 4;
        int cols = 3;
        Object[][] data = new Object[rows][cols+1];
        for(int i = 0; i < rows; i++) {
            data[0] = rowHeaders[i];
for(int j = 1; j <= cols; j++)
data[i][j] = allData[i][j-1];
interceptTableB = new JTable(data, headers) {
public boolean isCellEditable(int row, int col) {
return false;
DefaultTableCellRenderer renderer =
(DefaultTableCellRenderer)interceptTableB.getDefaultRenderer(String.class);
renderer.setHorizontalAlignment(JLabel.CENTER);
JPanel panel = new JPanel(new BorderLayout());
panel.setBorder(BorderFactory.createTitledBorder("triangle DEF"));
panel.add(interceptTableB);
return panel;
public JTextArea getJtextArea(){
tarea2 = new JTextArea();
tarea2.setText(notes[0]);
tarea2.setSize(400,0);
tarea2.setWrapStyleWord(true);
tarea2.setLineWrap(true);
return tarea2;
public JPanel getTxtPanel(){
JPanel panel = new JPanel(new GridLayout());
panel.setSize(600,600);
panel.add(getInterceptTablePanelB(), "South");
panel.add(getJtextArea(),"East");
return panel;
import java.awt.Point;
import java.awt.Rectangle;
import java.awt.event.MouseEvent;
import javax.swing.JTable;
import javax.swing.event.MouseInputAdapter;
* @author Sharan Bhojwani
public class InterceptControl extends MouseInputAdapter{
InterceptView view;
InterceptModel model;
Point start;
boolean dragging, altering;
Rectangle lineLens;
/** Creates a new instance of InterceptControl */
public InterceptControl(InterceptView tv) {
view = tv;
model = view.getModel();
dragging = altering = false;
lineLens = new Rectangle(0, 0, 6, 6);
public void mousePressed(MouseEvent e) {
* Point p = e.getPoint();
* lineLens.setLocation(p.x - 3, p.y - 3);
* // are we over a line
* if(model.isLineSelected(lineLens))
* start = p;
* altering = true;
* // or are we within the triangle
* else if(model.contains(p,model.getSmallTriangle()))
* start = p;
* dragging = true;
void setRatio(int ratio) {
model.setRatio(ratio);
updateInterceptTable();
//updateInterceptTableA();
// updateInterceptTableB();
public void mouseReleased(MouseEvent e) {
altering = false;
dragging = false;
//view.getCentroidLabel().setText("centroid location: " +
// model.findCentroid(model.getSmallTriangle()));
view.repaint(); // for the construction lines
public void mouseDragged(MouseEvent e) {
Point p = e.getPoint();
if(altering) {
int x = p.x - start.x;
int y = p.y - start.y;
model.moveSide(x, y, p);
updateInterceptTable();
//updateInterceptTableA();
// updateInterceptTableB();
view.repaint();
start = p;
else if(dragging)
int x = p.x - start.x;
int y = p.y - start.y;
model.translate(x, y, model.getSmallTriangle());
//model.translate(x, y, model.getBigTriangle());
view.repaint();
start = p;
//TABLE FOR FIRST TRIANLGE ABC
private void updateInterceptTable(){
String[] lengths = model.getLengths(model.getSmallTriangle());
// String[] squares = model.getSquares();
String[] angles = model.getAngles(model.getSmallTriangle());
JTable table = view.getInterceptTable();
for(int j = 0; j < angles.length; j++) {
table.setValueAt(lengths[j], 1, j + 1);
// table.setValueAt(squares[j], 2, j + 1);
table.setValueAt(angles[j], 3, j + 1);
//view.getCentroidLabel().setText("centroid location: " +
Now if you compile and run these classes - u will c two triangles on screen
ONE IS ABC AND THE OTHER WTIH VERTEX A an dsides D E -
now D and E are not labeled coz I was having problems with the labels coz everytime i incremented the JSLIDer the triangle changed shape and the lables interchanged
Now what I am trying to demonstrate here is the Triangle Intercept theorem which states that when BC is Parallel to DE - no matter what the size of the triangle the ratios of AB/BD = AC/AE ----
and in my triangle i got BC as the line parallelt o DE - so i have got 2 triangles one ABC (SMALLER TRIANGLE)_ and
ADE - Bigger triangle
with BC appearing as the line passing through the midpoint of SIDES AD AND AE -
I need to get the values of the ratios of the sides and i cant figure out how to calculate the values of sides AC and CE and AE - that should be updated automatically...
Can Any one help me with this - thanks

Answer 1

Hi again - The post before this is got the code for the problem at hand but the requirements have changed slightly -
So far I have managed to draw a 2Triangles on screen -
both are controlled by the JSlider
I need to have my triangles fixed in a certain position on screen -
I just need the one triangle and I need the Jslider controlling the line passing through the triangle which is parallelt o its base.
i.e. before i had two triangles witht he base of the smaller one acting as the parallel line through the midpoints...
now i need a line passing through the triangle not necessarily thorugh its midpoints but it should be parallel to its base..
and the Jslider should control this line such that as it increments the line moves down and decrements it moves up
and then the ratios can be calculated to show that AB:BD = AC:CE no matter where BC is the parallel line where the parallel line is within the triangles sides
secondly.. the user should be able to Drag any side of the triangle by its vertex and manipulate its lengths i.e . increase or decrease the size of the triangle using is vertex
can any one help me with his
Thanks...