L2.2.5 TD Périmètre

Comments.md

Dans ces exercices, vous utiliserez les classes Shape et Point pour répondre à des questions sur une forme composée d'une collection de points du plan x-y, comme indiqué dans le cours.

La forme est définie en traçant une ligne entre deux points adjacents, pour chaque paire de points adjacents, et une ligne entre le premier et le dernier point. Vous pouvez consulter la documentation des classes Shape, Point et FileResource à cette addresse: http://www.dukelearntoprogram.com/course2/doc/javadoc/edu/duke/package-summary.html

Dans ce devoir, vous allez compléter la classe PerimeterAssignmentRunner pour réaliser de nombreux calculs relatifs aux formes. Le squelette de cette classe a été écrit pour vous dans le projet BlueJ attaché. Ce projet contient également plusieurs fichiers de données. En outre, vous devrez consulter la documentation de la classe Shape et de la classe Point.

La classe PerimeterAssignmentRunner inclut déjà les méthodes complètes suivantes:

1. La méthode getPerimeter a un paramètre s de type Shape. Étant donné une forme, cette méthode renvoie le périmètre de la forme.
2. La méthode testPerimeter n’a pas de valeur de retour, son type de retour est donc null. Cette méthode est utilisée pour sélectionner un fichier de données à l'aide de la classe FileResource, créer une forme basée sur les points de ce fichier de données, puis calculer le périmètre de la forme et générer sa valeur.
3. La méthode triangle n'a pas de valeur de retour et crée un triangle que vous pouvez utiliser pour tester les méthodes que vous allez créer dans cette affectation.
4. La méthode main.

Pour ce devoir, vous allez ajouter ou modifier plusieurs méthodes dans la classe PerimeterAssigmentRunner.

Terminer l'implémentation de la méthode getNumPoints qui a un paramètre s de type Shape. Cette méthode renvoie un nombre entier correspondant au nombre de points dans la forme s. Astuce: vous devrez parcourir tous les points de la forme S et les compter.

1. Ajoutez le code dans la méthode testPerimeter pour appeler getNumPoints et afficher le résultat.
2. Terminez l’écriture de la méthode getAverageLength qui a un paramètre s de type Shape. Cette méthode renvoie un nombre de type double correspondant à la moyenne calculée de toutes les longueurs des côtés dans la forme S.
3. Ajoutez le code dans la méthode testPerimeter pour appeler la méthode getAverageLength et imprimer le résultat. Notez que si vous sélectionnez le fichier example1.txt, la longueur moyenne du côté doit être 4.0.
4. Terminez l’écriture de la méthode getLargestSide qui a un paramètre s de type Shape. Cette méthode renvoie un nombre de type double égal au plus long côté de la forme S.
5. Ajoutez le code dans la méthode testPerimeter pour appeler la méthode getLargestSide et afficher le résultat. Notez que si vous sélectionnez le fichier example1.txt, le côté le plus long doit être 5.0.
6. Terminez l'écriture de la méthode getLargestX qui a un paramètre s de type Shape. Cette méthode renvoie un nombre de type double correspondant à la plus grande valeur x sur tous les points des formes. 7.Ajoutez le code dans la méthode testPerimeter pour appeler la méthode getLargestX et imprimer le résultat. Notez que si vous sélectionnez le fichier example1.txt, l'abscisse maximale doit être 4.0.

Main.java

import java.io.File;
import java.util.ArrayList;
import java.util.Map;
import java.util.HashMap;
import java.util.Collection;

public class PerimeterAssignmentRunner {
    public double getPerimeter (Shape s) {
        // Start with totalPerim = 0
        double totalPerim = 0.0;
        // Start wth prevPt = the last point 
        Point prevPt = s.getLastPoint();
        // For each point currPt in the shape,
        for (Point currPt : s.getPoints()) {
            // Find distance from prevPt point to currPt 
            double currDist = prevPt.distance(currPt);
            // Update totalPerim by currDist
            totalPerim = totalPerim + currDist;
            // Update prevPt to be currPt
            prevPt = currPt;
        }
        // totalPerim is the answer
        return totalPerim;
    }

    public int getNumPoints (Shape s) {
        // Put code here
        return 0;
    }

    public double getAverageLength(Shape s) {
        // Put code here
        return 0.0;
    }

    public double getLargestSide(Shape s) {
        // Put code here
        return 0.0;
    }

    public double getLargestX(Shape s) {
        // Put code here
        return 0.0;
    }

    public double getLargestPerimeterMultipleFiles() {
        for(String file : FileResource.getFiles()){
             FileResource fr = new FileResource(file);
             Shape s = new Shape(fr);
             //Put Code Here
        }
        return 0.0;
    }

    public String getFileWithLargestPerimeter() {
        // Put code here
        File temp = null;    // replace this code
        return temp.getName();
    }

    public void testPerimeter () {
        FileResource fr = new FileResource("datatest1.txt");
        Shape s = new Shape(fr);
        double length = getPerimeter(s);
        System.out.println("perimeter = " + length);
    }
    
    public void testPerimeterMultipleFiles() {
        // Put code here
    }

    public void testFileWithLargestPerimeter() {
        // Put code here
    }

    // This method creates a triangle that you can use to test your other methods
    public void triangle(){
        Shape triangle = new Shape();
        triangle.addPoint(new Point(0,0));
        triangle.addPoint(new Point(6,0));
        triangle.addPoint(new Point(3,6));
        for (Point p : triangle.getPoints()){
            System.out.println(p);
        }
        double peri = getPerimeter(triangle);
        System.out.println("perimeter = "+peri);
    }


    public static void main (String[] args) {
        PerimeterAssignmentRunner pr = new PerimeterAssignmentRunner();
        pr.testPerimeter();
    }
    
    
    static class Shape {
    private ArrayList<Point> points;

    /**
     * Create an empty <code>Shape</code> object, one with no points.
     */
    public Shape () {
        points = new ArrayList<Point>();
    }

    /**
     * Create a <code>Shape</code> object from a file with x,y coordinates 
     * of points, in order, one pair of x,y per line.
     * 
     * Each x,y are comma-separated, e.g.,
     * <pre>
     *   3,4
     *  -2,5
     * </pre>
     * whitespace on line is skipped.
     * 
     * @param file is the FileResource accessible and bound to a file
     * with one pair of points per line
     */
    public Shape (FileResource file) {
        this();
        for (String line : file.lines()) {
            int commaloc = line.indexOf(",");
            int x = Integer.parseInt(line.substring(0, commaloc).trim());
            int y = Integer.parseInt(line.substring(commaloc + 1).trim());
            addPoint(new Point(x, y));
        }
    }
    
    /**
     * Add a point to this shape/polygon. 
     * 
     * The order in which points are added defines the order in which points are
     * accessed.
     * 
     * @param p is the Point added to this shape
     */
    public void addPoint (Point p) {
        points.add(p);
    }

    /**
     * Return the last point added to this shape/polygon
     * 
     * @return the last Point added
     */
    public Point getLastPoint () {
        return points.get(points.size() - 1);
    }

    /**
     * Allow access to this shape one point at a time.
     * 
     * @return an Iterable that allows access to points
     */
    public Iterable<Point> getPoints () {
        return points;
    }
}

static public class Point {
    private int x;
    private int y;

    /**
     * Create a <code>Point</code> object from x and y coordinates.
     * 
     * @param startx is the x-coordinate
     * @param starty is the y-coordinate
     */
    public Point (int startx, int starty) {
        x = startx;
        y = starty;
    }

    /**
     * Returns the x coordinate of this point.
     * 
     * @return x coordinate
     */
    public int getX () {
        return x;
    }

    /**
     * Returns the y coordinate of this point.
     * 
     * @return y coordinate
     */
    public int getY () {
        return y;
    }

    /**
     * Calculate and return the Euclidean distance from this point to another point.
     * 
     * @param otherPt the other point to which distance is calculated
     * @return the distance from this point to otherPt
     */
    public double distance (Point otherPt) {
        int dx = x - otherPt.getX();
        int dy = y - otherPt.getY();
        return Math.sqrt(dx * dx + dy * dy);
    }
    
    /**
     * Returns a string representation of this point.
     * 
     * @return (x,y) for this point.
     */
    public String toString(){
        return "("+x+","+y+")";
    }


}

 static class FileResource{
        private final static Map<String,String> content;
        static {
            content=new HashMap<>();
            content.put("datatest1.txt","-3,3\n-4,-3\n4,-2\n6,5\n");
            content.put("datatest2.txt","-3,4\n-3,-5\n3,-5\n3,4\n");
            content.put("datatest3.txt","-4, -3\n4, -2\n12, 2\n6, 5\n-3, 3\n-8, 1\n\n");
            content.put("datatest4.txt","-3, 9\n-8, 7\n-12, 4\n-6, -2\n-4, -6\n2, -8\n6, -5\n10, -3\n8, 5\n4, 8\n");
            content.put("datatest5.txt","-15,8\n-8,-6\n7,-2\n4,10\n");
            content.put("datatest5.txt","-13,8\n-8,-6\n5,-2\n2,10\n");
            content.put("exemple1.txt","-1,  3\n-1, -1\n 4, -1\n 1,  3\n");
            
            
            
            
        }
        
        public static Collection<String> getFiles(){
            return content.keySet();
        }
        private final String resource;
        public FileResource(String ref){
            resource=content.get(ref);
        }
        
        public String[] lines(){
            return resource.split("\n");
        }
        
    }


    
}

execute me on https://java.miage.dev/?gistId=79346707a25c59b67e8ee3aa38b9f9cd