3D-Objekte/Bounding-Box

Diese Seite verwendet Cookies. Durch die Nutzung unserer Seite erklären Sie sich damit einverstanden, dass wir Cookies setzen. Weitere Informationen

  • 3D-Objekte/Bounding-Box

    Hier eine erste lauffähige Version der Aufgabe für Donnerstag. Bin mir allerdings nicht ganz sicher, ob es das ist, was Herr Schwanecke will. Der Zylinder kann nur senkrecht zur x-Achse gesetzt werden. Wäre interessant, was ihr so für Lösungen habt...

    Quellcode

    1. package Aufgabe02;
    3. import java.util.*;
    5. /**
    6. * Programmieren 2, II.Semester / FH-Wiesbaden<br>
    7. * Uebung03/Aufgabe02<br>
    8. * Programm zur repraesentation von dreidimensionalen Objekten<br>
    9. * getestet mit WinXP(Servicepack 2)/ Fedora Core
    10. *
    11. * @author Sebastian Schmitt
    12. * @version 1.0
    13. */
    14. public class Obj3d {
    16. /**
    17. * @param args
    18. * Kommandozeilenparameter
    19. */
    20. public static void main(String[] args) {
    21. Scanner sc = new Scanner(System.in);
    23. System.out.print("bitte waehlen: \n1)Kugel \n2)Wuerfel \n3)Zylinder :");
    24. int auswahl = Integer.parseInt(sc.next());
    26. if (auswahl == 1) { // Kugel
    28. Kugel k = new Kugel();
    29. System.out.print("x-Koordinate des Kreismittelpunktes:");
    30. k.setzeX(Integer.parseInt(sc.next()));
    31. System.out.print("y-Koordinate des Kreismittelpunktes:");
    32. k.setzeY(Integer.parseInt(sc.next()));
    33. System.out.print("z-Koordinate des Kreismittelpunktes:");
    34. k.setzeZ(Integer.parseInt(sc.next()));
    35. System.out.print("Radius des Kreises:");
    36. k.setzeR(Integer.parseInt(sc.next()));
    38. System.out.println(k);
    39. }
    41. else if (auswahl == 2) { // Wuerfel
    42. Wuerfel w = new Wuerfel();
    43. System.out.print("x-Koordinate des Wuerfelmittelpunktes:");
    44. w.setzeX(Integer.parseInt(sc.next()));
    45. System.out.print("y-Koordinate des Wuerfelmittelpunktes:");
    46. w.setzeY(Integer.parseInt(sc.next()));
    47. System.out.print("z-Koordinate des Wuerfelmittelpunktes:");
    48. w.setzeZ(Integer.parseInt(sc.next()));
    49. System.out.print("Durchmesser des Wuerfels:");
    50. w.setzeD(Integer.parseInt(sc.next()));
    52. System.out.println(w);
    53. }
    55. else { // Zylinder
    56. Zylinder z = new Zylinder();
    57. System.out
    58. .print("x-Koordinate des Mittelpunktes der Grundflaeche:");
    59. z.setzeX(Integer.parseInt(sc.next()));
    60. System.out
    61. .print("y-Koordinate des Mittelpunktes der Grundflaeche:");
    62. z.setzeY(Integer.parseInt(sc.next()));
    63. System.out
    64. .print("z-Koordinate des Mittelpunktes der Grundflaeche:");
    65. z.setzeZ(Integer.parseInt(sc.next()));
    66. System.out.print("Radius des Zylinders:");
    67. z.setzeR(Integer.parseInt(sc.next()));
    68. System.out.print("Hoehe des Zylinders:");
    69. z.setzeH(Integer.parseInt(sc.next()));
    71. System.out.println(z);
    72. }
    74. }
    76. }
    78. abstract class D3Obj {
    79. final float pi = 3.141592654f;
    81. final float vierdrittel = 1.3333333333333f;
    83. double x;
    85. double y;
    87. double z;
    89. double bboxx; // x-
    91. double bboxy; // y-
    93. double bboxz; // z- Koordinate der Bounding-Box
    95. double bboxb; // breite-
    97. double bboxh; // hoehe-
    99. double bboxt; // tiefe der Bounding-Box
    101. void setzeX(double x) {
    102. this.bboxx = x;
    103. }
    105. void setzeY(double y) {
    106. this.bboxy = y;
    107. }
    109. void setzeZ(double z) {
    110. this.bboxz = z;
    111. }
    113. void setzeBreite(double b) {
    114. this.bboxb = b;
    115. }
    117. void setzeHoehe(double h) {
    118. this.bboxh = h;
    119. }
    121. void setzeTiefe(double t) {
    122. this.bboxt = t;
    123. }
    125. String leseOberflaecheBbox() {
    126. double x = 2 * (bboxb * bboxh + bboxb * bboxt + bboxh * bboxt);
    127. return "Oberflaeche: " + x + "\n";
    128. }
    130. String leseVolumenBbox() {
    131. double x = bboxb * bboxh * bboxt;
    132. return "Volumen: " + x + "\n";
    133. }
    135. abstract String leseOberflaeche();
    137. abstract String leseVolumen();
    139. String print() {
    140. return "\nBounding-Box:\n" + "untere Ecke:(" + bboxx + "," + bboxy
    141. + "," + bboxz + ")\n" + "b/h/t: (" + bboxb + "," + bboxh + ","
    142. + bboxt + ")\n" + leseOberflaecheBbox() + leseVolumenBbox();
    143. }
    144. }
    146. class Kugel extends D3Obj {
    148. double radius;
    150. void setzeX(double x) {
    151. this.x = x;
    152. }
    154. void setzeY(double y) {
    155. this.y = y;
    156. }
    158. void setzeZ(double z) {
    159. this.z = z;
    160. }
    162. void setzeR(double r) {
    163. this.radius = r;
    164. super.setzeX(this.x - this.radius);
    165. super.setzeY(this.y - this.radius);
    166. super.setzeZ(this.z - this.radius);
    167. super.setzeBreite(2 * this.radius);
    168. super.setzeHoehe(2 * this.radius);
    169. super.setzeTiefe(2 * this.radius);
    170. }
    172. String leseOberflaeche() {
    173. return "Oberflaeche: " + 4 * pi * (radius * radius) + "\n";
    174. }
    176. String leseVolumen() {
    177. return "Volumen: " + (vierdrittel) * pi * (radius * radius * radius)
    178. + "\n";
    179. }
    181. public String toString() {
    182. return super.print() + "Kugel:\n" + "Koordinaten des Mittelpunktes:("
    183. + x + "," + y + "," + z + ")\n" + "Radius: " + radius + "\n"
    184. + leseOberflaeche() + leseVolumen();
    185. }
    186. }
    188. class Wuerfel extends D3Obj {
    189. double durchmesser;
    191. void setzeX(int x) {
    192. this.x = x;
    193. }
    195. void setzeY(int y) {
    196. this.y = y;
    197. }
    199. void setzeZ(int z) {
    200. this.z = z;
    201. }
    203. void setzeD(int d) {
    204. this.durchmesser = d;
    205. super.setzeX(this.x - this.durchmesser / 2);
    206. super.setzeY(this.y - this.durchmesser / 2);
    207. super.setzeZ(this.z - this.durchmesser / 2);
    208. super.setzeBreite(this.durchmesser);
    209. super.setzeHoehe(this.durchmesser);
    210. super.setzeTiefe(this.durchmesser);
    211. }
    213. String leseOberflaeche() {
    214. return "Oberflaeche: " + 6 * (durchmesser * durchmesser) + "\n";
    215. }
    217. String leseVolumen() {
    218. return "Volumen: " + durchmesser * durchmesser * durchmesser + "\n";
    219. }
    221. public String toString() {
    222. return super.print() + "Wuerfel:\n" + "Koordinaten des Mittelpunktes:("
    223. + x + "," + y + "," + z + ")\n" + "Durchmesser: " + durchmesser
    224. + "\n" + leseOberflaeche() + leseVolumen();
    225. }
    226. }
    228. class Zylinder extends D3Obj {
    229. double radius;
    231. double hoehe;
    233. void setzeX(double x) {
    234. this.x = x;
    235. }
    237. void setzeY(double y) {
    238. this.y = y;
    239. }
    241. void setzeZ(double z) {
    242. this.z = z;
    243. }
    245. void setzeR(double r) {
    246. this.radius = r;
    247. }
    249. void setzeH(double h) {
    250. this.hoehe = h;
    251. super.setzeX(this.x - this.radius);
    252. super.setzeY(this.y - this.radius);
    253. super.setzeZ(this.z - this.radius);
    254. super.setzeBreite(this.radius * 2);
    255. super.setzeHoehe(this.hoehe);
    256. super.setzeTiefe(this.radius * 2);
    257. }
    259. String leseOberflaeche() {
    260. return "Oberflaeche: " + 2 * pi * radius * hoehe + "\n";
    261. }
    263. String leseVolumen() {
    264. return "Volumen: " + pi * radius * radius * hoehe + "\n";
    265. }
    267. public String toString() {
    268. return super.print() + "Wuerfel:\n"
    269. + "Koordinaten des Mittelpunktes der Grundflaeche:(" + x + ","
    270. + y + "," + z + ")\n" + "Radius: " + radius + "\nHoehe: "
    271. + hoehe + "\n" + leseOberflaeche() + leseVolumen();
    272. }
    273. }
    Alles anzeigen

  • Hi!

    Ich bin zwar nicht bei euch im Studiengang aber die Aufgaben mach ich ganz gerne mit :)

    Die Aufgabenstellung an sich fand ich allgemein ein wenig schwammig.
    Mir ist aufgefallen dass im dargestellten Beispiel das Koordinatensystem nicht ganz stimmt. Nach dem Koordinatensystem auf Wikipedia.de (http://de.wikipedia.org/wiki/Koordinatensystem) müßte die linke untere Ecke für das Kugel-Beispiel den Z-Wert 1 (also positiv) und nicht -1 haben.
    Vielleicht habe ich aber auch nur die Aufgabenstellung nicht ganz verstanden :wink:

    Für speziell dein Beispiel noch zwei Tipps:
    Die Kreiszahl PI ist eine Konstante der Klasse Math, du kannst sie also direkt über Math.PI ansprechen.


    edit: hab mich vertan Math.pow(zahl1,zahl2) ist nur der ausdruck in java für zahl1^zahl2, sorry!
    :oops:

    4/3 könntest du in der berechnung der double zahl mit (4d/3d) ausdrücken, wenn du (4/3) schreibst versteht der compiler das nicht weil die zahlen 4 und 3 vom typ int wären.

  • hi,

    wenn ich fragen darf: wer bist du dann? Das Aufgabenblatt hast du?
    Bei der Gelegenheit...
    meldet euch doch ALLE mal im Who is Who-Thread und stellt euch vor

    Quellcode

    1. /**
    2. * @author Torben Brodt
    3. * <p />Bounding Box
    4. * <p />Funktioniert ab Java 1.5
    5. */
    6. import java.util.*;
    7. public class A03_Bounding_Box {
    9. public static void main(String[] args) {
    11. // Eingabe von Tastatur lesen
    12. Scanner sc = new Scanner(System.in);
    13. int[] queries;
    14. Box objekt;
    16. System.out.print("Bitte waehlen Sie: 1 (Kugel), 2 (Wuerfel), 3 (Zylinder)\t\t: ");
    17. int choice = sc.nextInt();
    19. switch(choice) // Eingaben
    20. {
    21. case 1: // Kugel
    22. queries = queries("Kreismittelpunktes");
    23. System.out.print("Bitte geben Sie den Radius der Kugel ein\t\t\t: ");
    24. queries[3] = sc.nextInt();
    25. objekt = new Kugel(queries[0], queries[1], queries[2], queries[3]);
    26. break;
    27. case 2: // Wuerfel
    28. queries = queries("Wuerfelmittelpunktes");
    29. System.out.print("Bitte geben Sie die Laenge des Wuerfels ein\t\t\t: ");
    30. queries[3] = sc.nextInt();
    31. objekt = new Wuerfel(queries[0], queries[1], queries[2], queries[3]);
    32. break;
    33. case 3: // Zylinder
    34. queries = queries("Zylindermittelpunktes");
    35. System.out.print("Bitte geben Sie den Radius des Zylinders ein\t\t\t: ");
    36. queries[3] = sc.nextInt();
    37. System.out.print("Bitte geben Sie die Hoehe des Zylinders ein\t\t\t: ");
    38. queries[4] = sc.nextInt();
    39. objekt = new Zylinder(queries[0], queries[1], queries[2], queries[3], queries[4]);
    40. break;
    41. default:
    42. System.out.println("Fehler bei der Eingabe");
    43. objekt = new Kugel(1,1,1,1); //Damit mir Eclipse keine Fehler zeigt
    44. System.exit(0);
    45. }
    46. System.out.println(objekt);
    47. }
    49. /**
    50. * Stellt ein paar Standardfragen
    51. * @param input -> Füllt den Platzhalter in der Frage
    52. * @return -> gibt ein 5er Array mit den 3 vorselektierten Antworten zurück
    53. */
    54. static int[] queries(String input) {
    55. int[] queries = new int[5];
    56. Scanner sc = new Scanner(System.in);
    58. System.out.print("Bitte geben Sie die x-Koordinate des "+input+" ein\t: ");
    59. queries[0] = sc.nextInt();
    60. System.out.print("Bitte geben Sie die y-Koordinate des "+input+" ein\t: ");
    61. queries[1] = sc.nextInt();
    62. System.out.print("Bitte geben Sie die z-Koordinate des "+input+" ein\t: ");
    63. queries[2] = sc.nextInt();
    64. return queries;
    65. }
    67. }
    69. /**
    70. * abstrakte Bounding Box Hauptklasse
    71. * @author tbr
    72. */
    73. abstract class Box {
    74. private int x, y, z;
    75. private int centerx, centery, centerz;
    76. protected int hoehe, breite, tiefe;
    78. //Abstrakte Funktionen, die in den abgeleiteten Klassen vorkommen müssen
    79. abstract String leseOberflaeche();
    80. abstract String leseVolumen();
    82. //SET
    83. void setzeX(int x) {
    84. this.x = x;
    85. }
    86. void setzeY(int y) {
    87. this.y = y;
    88. }
    89. void setzeZ(int z) {
    90. this.z = z;
    91. }
    92. void setzeBreite(int breite) {
    93. this.breite = breite;
    94. }
    95. void setzeHoehe(int hoehe) {
    96. this.hoehe = hoehe;
    97. }
    98. void setzeTiefe(int tiefe) {
    99. this.tiefe = tiefe;
    100. }
    101. void setzeMittelpunkt(int centerx, int centery, int centerz) {
    102. this.centerx = centerx;
    103. this.centery = centery;
    104. this.centerz = centerz;
    105. }
    106. //GET
    107. String leseBreite() {
    108. return "\nBreite\t\t\t: "+this.breite;
    109. }
    110. String leseHoehe() {
    111. return "\nHoehe\t\t\t\t: "+this.hoehe;
    112. }
    113. String leseTiefe() {
    114. return "\nTiefe\t\t\t: "+this.tiefe;
    115. }
    116. String leseMittelpunkt() {
    117. return "\nKoordinaten des Mittelpunkts\t: ("+centerx+","+centery+","+centerz+")";
    118. }
    119. String round(double decimal) {
    120. return ""+(Math.round(decimal * 100000) / 100000.);
    121. }
    123. // Konstruktor
    124. public Box(int x, int y, int z) {
    125. this.x = x;
    126. this.y = y;
    127. this.z = z;
    128. }
    130. // Ueberschreibt die Stringkonvertierung
    131. public String toString() {
    132. return "---" +
    133. "\nBounding-Box:" +
    134. "\nKoordinaten der \"unteren\" Ecke\t: ("+this.x+","+this.y+","+this.z+")" +
    135. "\nHoehe, Breite, Tiefe\t\t: ("+this.hoehe+","+this.breite+","+this.tiefe+")" +
    136. "\nOberflaeche\t\t\t: "+2*(this.hoehe*this.breite + this.hoehe*this.tiefe + this.breite*this.tiefe)+
    137. "\nVolumen\t\t\t\t: "+(this.hoehe*this.breite*this.tiefe);
    138. }
    139. }
    141. class Kugel extends Box {
    142. int radius;
    143. // die abstrakte Funktion der Basisklasse
    144. String leseOberflaeche() {
    145. return "\nOberflaeche\t\t\t: " + round(4 * Math.PI * radius * radius);
    146. }
    147. // abstrakte Funktion der Basisklasse
    148. String leseVolumen() {
    149. return "\nVolumen\t\t\t\t: " + round((4d/3d) * Math.PI * radius*radius*radius);
    150. }
    151. String leseRadius() {
    152. return "\nRadius\t\t\t\t: "+this.radius;
    153. }
    154. void setzeRadius(int radius) {
    155. this.radius = radius;
    156. }
    158. // Ueberschreibt die Stringkonvertierung (ruft auch die Funktion der Basisklasse auf)
    159. public String toString() {
    160. return super.toString() + "\n\nKugel:" +
    161. leseMittelpunkt() + leseRadius() + leseOberflaeche() + leseVolumen();
    162. }
    164. // Konstruktor
    165. public Kugel(int x, int y, int z, int radius) {
    166. super(x-radius, y-radius, z-radius);
    167. setzeMittelpunkt(x,y,z);
    168. setzeRadius(radius);
    169. setzeBreite(2*radius); // Durchmesser
    170. setzeHoehe(2*radius); // Durchmesser
    171. setzeTiefe(2*radius); // Durchmesser
    172. }
    173. }
    175. class Wuerfel extends Box {
    176. int laenge;
    177. String leseOberflaeche() {
    178. return "\nOberflaeche\t\t\t: " + round(6*laenge*laenge);
    179. }
    180. String leseVolumen() {
    181. return "\nVolumen\t\t\t\t: " + round(laenge*laenge*laenge);
    182. }
    183. String leseLaenge() {
    184. return "\nLaenge\t\t\t\t: "+this.laenge;
    185. }
    186. void setzeLaenge(int laenge) {
    187. this.laenge = laenge;
    188. }
    190. public String toString() {
    191. return super.toString() + "\n\nWuerfel:" +
    192. leseMittelpunkt() + leseLaenge() + leseOberflaeche() + leseVolumen();
    193. }
    195. public Wuerfel(int x, int y, int z, int laenge) {
    196. super(x-laenge/2, y-laenge/2, z-laenge/2);
    197. setzeMittelpunkt(x,y,z);
    198. setzeBreite(laenge);
    199. setzeHoehe(laenge);
    200. setzeTiefe(laenge);
    201. setzeLaenge(laenge);
    202. }
    203. }
    205. class Zylinder extends Box {
    206. int radius;
    207. String leseOberflaeche() {
    208. return "\nOberflaeche\t\t\t: " + round(2 * Math.PI * radius * hoehe + (2*Math.PI * radius*radius));
    209. }
    210. String leseVolumen() {
    211. return "\nVolumen\t\t\t\t: " + round(Math.PI * (radius*radius) * hoehe);
    212. }
    213. String leseRadius() {
    214. return "\nRadius\t\t\t\t: "+this.radius;
    215. }
    216. void setzeRadius(int radius) {
    217. this.radius = radius;
    218. }
    220. public String toString() {
    221. return super.toString() + "\n\nZylinder:" +
    222. leseMittelpunkt() + leseHoehe() + leseRadius() + leseOberflaeche() + leseVolumen();
    223. }
    225. public Zylinder(int x, int y, int z, int radius, int hoehe) {
    226. super(x-radius, y, z-radius);
    227. setzeMittelpunkt(x,y,z);
    228. setzeRadius(radius);
    229. setzeBreite(2*radius); // Durchmesser
    230. setzeHoehe(hoehe);
    231. setzeTiefe(2*radius); // Durchmesser
    232. }
    233. }
    Alles anzeigen