cs330-polyhedra-java/BoundingBox.java at main · code-help-tutor/cs330-polyhedra-java · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
WeChat: cstutorcs
QQ: 749389476
Email: tutorcs@163.com
/**
 * Rectangular prism representing the boundaries
 * x, y, and z of a polyhedron
 */
publicclassBoundingBox {
/**
 * Lower boundary. In this exercise, it is
 * fixed at (0,0,0)
 */
privatePointlowerLeftVertex;

/**
 * Upper boundary
 */
privatePointupperRightVertex;

/**
 * Default Constructor
 */
publicBoundingBox()
 {
lowerLeftVertex = newPoint(0, 0, 0);
upperRightVertex = newPoint(0, 0, 0);
 }

/**
 * Construct a bounding box from lower and upper
 * points that define it
 */
publicBoundingBox(PointlowerLeft, PointupperRight)
 {
lowerLeftVertex = lowerLeft;
upperRightVertex = upperRight;
 }

/**
 * Retrieve the upper boundary
 */
publicPointgetUpperRightVertex()
 {
returnupperRightVertex;
 }

/**
 * Set the upper boundary using a Point
 */
publicvoidsetUpperRightVertex(Pointu)
 {
upperRightVertex = u;
 }

/**
 * Set the upper boundary using the x, y, and z
 * components
 */
publicvoidsetUpperRightVertex(doublex, doubley, doublez)
 {
upperRightVertex.x = x;
upperRightVertex.y = y;
upperRightVertex.z = z;
 }

/**
 * Merge two bounding boxes, taking the
 * largest values for each of x, y, and z
 */
publicvoidmerge(BoundingBoxother)
 {
upperRightVertex.x = Math.max(this.upperRightVertex.x,
other.upperRightVertex.x);

upperRightVertex.y = Math.max(this.upperRightVertex.y,
other.upperRightVertex.y);

upperRightVertex.z = Math.max(this.upperRightVertex.z,
other.upperRightVertex.z);
 }

/**
 * Apply a scaling factor
 */
publicvoidscale(doubles)
 {
upperRightVertex.scale(s);
 }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
WeChat: cstutorcs
QQ: 749389476
Email: tutorcs@163.com
/**
 * Rectangular prism representing the boundaries
 * x, y, and z of a polyhedron
 */
publicclassBoundingBox {
/**
 * Lower boundary. In this exercise, it is
 * fixed at (0,0,0)
 */
privatePointlowerLeftVertex;

/**
 * Upper boundary
 */
privatePointupperRightVertex;

/**
 * Default Constructor
 */
publicBoundingBox()
 {
lowerLeftVertex = newPoint(0, 0, 0);
upperRightVertex = newPoint(0, 0, 0);
 }

/**
 * Construct a bounding box from lower and upper
 * points that define it
 */
publicBoundingBox(PointlowerLeft, PointupperRight)
 {
lowerLeftVertex = lowerLeft;
upperRightVertex = upperRight;
 }

/**
 * Retrieve the upper boundary
 */
publicPointgetUpperRightVertex()
 {
returnupperRightVertex;
 }

/**
 * Set the upper boundary using a Point
 */
publicvoidsetUpperRightVertex(Pointu)
 {
upperRightVertex = u;
 }

/**
 * Set the upper boundary using the x, y, and z
 * components
 */
publicvoidsetUpperRightVertex(doublex, doubley, doublez)
 {
upperRightVertex.x = x;
upperRightVertex.y = y;
upperRightVertex.z = z;
 }

/**
 * Merge two bounding boxes, taking the
 * largest values for each of x, y, and z
 */
publicvoidmerge(BoundingBoxother)
 {
upperRightVertex.x = Math.max(this.upperRightVertex.x,
other.upperRightVertex.x);

upperRightVertex.y = Math.max(this.upperRightVertex.y,
other.upperRightVertex.y);

upperRightVertex.z = Math.max(this.upperRightVertex.z,
other.upperRightVertex.z);
 }

/**
 * Apply a scaling factor
 */
publicvoidscale(doubles)
 {
upperRightVertex.scale(s);
 }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
WeChat: cstutorcs
QQ: 749389476
Email: tutorcs@163.com
/**
 * Rectangular prism representing the boundaries
 * x, y, and z of a polyhedron
 */
publicclassBoundingBox {
/**
 * Lower boundary. In this exercise, it is
 * fixed at (0,0,0)
 */
privatePointlowerLeftVertex;

/**
 * Upper boundary
 */
privatePointupperRightVertex;

/**
 * Default Constructor
 */
publicBoundingBox()
 {
lowerLeftVertex = newPoint(0, 0, 0);
upperRightVertex = newPoint(0, 0, 0);
 }

/**
 * Construct a bounding box from lower and upper
 * points that define it
 */
publicBoundingBox(PointlowerLeft, PointupperRight)
 {
lowerLeftVertex = lowerLeft;
upperRightVertex = upperRight;
 }

/**
 * Retrieve the upper boundary
 */
publicPointgetUpperRightVertex()
 {
returnupperRightVertex;
 }

/**
 * Set the upper boundary using a Point
 */
publicvoidsetUpperRightVertex(Pointu)
 {
upperRightVertex = u;
 }

/**
 * Set the upper boundary using the x, y, and z
 * components
 */
publicvoidsetUpperRightVertex(doublex, doubley, doublez)
 {
upperRightVertex.x = x;
upperRightVertex.y = y;
upperRightVertex.z = z;
 }

/**
 * Merge two bounding boxes, taking the
 * largest values for each of x, y, and z
 */
publicvoidmerge(BoundingBoxother)
 {
upperRightVertex.x = Math.max(this.upperRightVertex.x,
other.upperRightVertex.x);

upperRightVertex.y = Math.max(this.upperRightVertex.y,
other.upperRightVertex.y);

upperRightVertex.z = Math.max(this.upperRightVertex.z,
other.upperRightVertex.z);
 }

/**
 * Apply a scaling factor
 */
publicvoidscale(doubles)
 {
upperRightVertex.scale(s);
 }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
WeChat: cstutorcs
QQ: 749389476
Email: tutorcs@163.com
/**
 * Rectangular prism representing the boundaries
 * x, y, and z of a polyhedron
 */
publicclassBoundingBox {
/**
 * Lower boundary. In this exercise, it is
 * fixed at (0,0,0)
 */
privatePointlowerLeftVertex;

/**
 * Upper boundary
 */
privatePointupperRightVertex;

/**
 * Default Constructor
 */
publicBoundingBox()
 {
lowerLeftVertex = newPoint(0, 0, 0);
upperRightVertex = newPoint(0, 0, 0);
 }

/**
 * Construct a bounding box from lower and upper
 * points that define it
 */
publicBoundingBox(PointlowerLeft, PointupperRight)
 {
lowerLeftVertex = lowerLeft;
upperRightVertex = upperRight;
 }

/**
 * Retrieve the upper boundary
 */
publicPointgetUpperRightVertex()
 {
returnupperRightVertex;
 }

/**
 * Set the upper boundary using a Point
 */
publicvoidsetUpperRightVertex(Pointu)
 {
upperRightVertex = u;
 }

/**
 * Set the upper boundary using the x, y, and z
 * components
 */
publicvoidsetUpperRightVertex(doublex, doubley, doublez)
 {
upperRightVertex.x = x;
upperRightVertex.y = y;
upperRightVertex.z = z;
 }

/**
 * Merge two bounding boxes, taking the
 * largest values for each of x, y, and z
 */
publicvoidmerge(BoundingBoxother)
 {
upperRightVertex.x = Math.max(this.upperRightVertex.x,
other.upperRightVertex.x);

upperRightVertex.y = Math.max(this.upperRightVertex.y,
other.upperRightVertex.y);

upperRightVertex.z = Math.max(this.upperRightVertex.z,
other.upperRightVertex.z);
 }

/**
 * Apply a scaling factor
 */
publicvoidscale(doubles)
 {
upperRightVertex.scale(s);
 }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
WeChat: cstutorcs
QQ: 749389476
Email: tutorcs@163.com
/**
 * Rectangular prism representing the boundaries
 * x, y, and z of a polyhedron
 */
publicclassBoundingBox {
/**
 * Lower boundary. In this exercise, it is
 * fixed at (0,0,0)
 */
privatePointlowerLeftVertex;

/**
 * Upper boundary
 */
privatePointupperRightVertex;

/**
 * Default Constructor
 */
publicBoundingBox()
 {
lowerLeftVertex = newPoint(0, 0, 0);
upperRightVertex = newPoint(0, 0, 0);
 }

/**
 * Construct a bounding box from lower and upper
 * points that define it
 */
publicBoundingBox(PointlowerLeft, PointupperRight)
 {
lowerLeftVertex = lowerLeft;
upperRightVertex = upperRight;
 }

/**
 * Retrieve the upper boundary
 */
publicPointgetUpperRightVertex()
 {
returnupperRightVertex;
 }

/**
 * Set the upper boundary using a Point
 */
publicvoidsetUpperRightVertex(Pointu)
 {
upperRightVertex = u;
 }

/**
 * Set the upper boundary using the x, y, and z
 * components
 */
publicvoidsetUpperRightVertex(doublex, doubley, doublez)
 {
upperRightVertex.x = x;
upperRightVertex.y = y;
upperRightVertex.z = z;
 }

/**
 * Merge two bounding boxes, taking the
 * largest values for each of x, y, and z
 */
publicvoidmerge(BoundingBoxother)
 {
upperRightVertex.x = Math.max(this.upperRightVertex.x,
other.upperRightVertex.x);

upperRightVertex.y = Math.max(this.upperRightVertex.y,
other.upperRightVertex.y);

upperRightVertex.z = Math.max(this.upperRightVertex.z,
other.upperRightVertex.z);
 }

/**
 * Apply a scaling factor
 */
publicvoidscale(doubles)
 {
upperRightVertex.scale(s);
 }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
WeChat: cstutorcs
QQ: 749389476
Email: tutorcs@163.com
/**
 * Rectangular prism representing the boundaries
 * x, y, and z of a polyhedron
 */
publicclassBoundingBox {
/**
 * Lower boundary. In this exercise, it is
 * fixed at (0,0,0)
 */
privatePointlowerLeftVertex;

/**
 * Upper boundary
 */
privatePointupperRightVertex;

/**
 * Default Constructor
 */
publicBoundingBox()
 {
lowerLeftVertex = newPoint(0, 0, 0);
upperRightVertex = newPoint(0, 0, 0);
 }

/**
 * Construct a bounding box from lower and upper
 * points that define it
 */
publicBoundingBox(PointlowerLeft, PointupperRight)
 {
lowerLeftVertex = lowerLeft;
upperRightVertex = upperRight;
 }

/**
 * Retrieve the upper boundary
 */
publicPointgetUpperRightVertex()
 {
returnupperRightVertex;
 }

/**
 * Set the upper boundary using a Point
 */
publicvoidsetUpperRightVertex(Pointu)
 {
upperRightVertex = u;
 }

/**
 * Set the upper boundary using the x, y, and z
 * components
 */
publicvoidsetUpperRightVertex(doublex, doubley, doublez)
 {
upperRightVertex.x = x;
upperRightVertex.y = y;
upperRightVertex.z = z;
 }

/**
 * Merge two bounding boxes, taking the
 * largest values for each of x, y, and z
 */
publicvoidmerge(BoundingBoxother)
 {
upperRightVertex.x = Math.max(this.upperRightVertex.x,
other.upperRightVertex.x);

upperRightVertex.y = Math.max(this.upperRightVertex.y,
other.upperRightVertex.y);

upperRightVertex.z = Math.max(this.upperRightVertex.z,
other.upperRightVertex.z);
 }

/**
 * Apply a scaling factor
 */
publicvoidscale(doubles)
 {
upperRightVertex.scale(s);
 }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
WeChat: cstutorcs
QQ: 749389476
Email: tutorcs@163.com
/**
 * Rectangular prism representing the boundaries
 * x, y, and z of a polyhedron
 */
publicclassBoundingBox {
/**
 * Lower boundary. In this exercise, it is
 * fixed at (0,0,0)
 */
privatePointlowerLeftVertex;

/**
 * Upper boundary
 */
privatePointupperRightVertex;

/**
 * Default Constructor
 */
publicBoundingBox()
 {
lowerLeftVertex = newPoint(0, 0, 0);
upperRightVertex = newPoint(0, 0, 0);
 }

/**
 * Construct a bounding box from lower and upper
 * points that define it
 */
publicBoundingBox(PointlowerLeft, PointupperRight)
 {
lowerLeftVertex = lowerLeft;
upperRightVertex = upperRight;
 }

/**
 * Retrieve the upper boundary
 */
publicPointgetUpperRightVertex()
 {
returnupperRightVertex;
 }

/**
 * Set the upper boundary using a Point
 */
publicvoidsetUpperRightVertex(Pointu)
 {
upperRightVertex = u;
 }

/**
 * Set the upper boundary using the x, y, and z
 * components
 */
publicvoidsetUpperRightVertex(doublex, doubley, doublez)
 {
upperRightVertex.x = x;
upperRightVertex.y = y;
upperRightVertex.z = z;
 }

/**
 * Merge two bounding boxes, taking the
 * largest values for each of x, y, and z
 */
publicvoidmerge(BoundingBoxother)
 {
upperRightVertex.x = Math.max(this.upperRightVertex.x,
other.upperRightVertex.x);

upperRightVertex.y = Math.max(this.upperRightVertex.y,
other.upperRightVertex.y);

upperRightVertex.z = Math.max(this.upperRightVertex.z,
other.upperRightVertex.z);
 }

/**
 * Apply a scaling factor
 */
publicvoidscale(doubles)
 {
upperRightVertex.scale(s);
 }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
WeChat: cstutorcs
QQ: 749389476
Email: tutorcs@163.com
/**
 * Rectangular prism representing the boundaries
 * x, y, and z of a polyhedron
 */
publicclassBoundingBox {
/**
 * Lower boundary. In this exercise, it is
 * fixed at (0,0,0)
 */
privatePointlowerLeftVertex;

/**
 * Upper boundary
 */
privatePointupperRightVertex;

/**
 * Default Constructor
 */
publicBoundingBox()
 {
lowerLeftVertex = newPoint(0, 0, 0);
upperRightVertex = newPoint(0, 0, 0);
 }

/**
 * Construct a bounding box from lower and upper
 * points that define it
 */
publicBoundingBox(PointlowerLeft, PointupperRight)
 {
lowerLeftVertex = lowerLeft;
upperRightVertex = upperRight;
 }

/**
 * Retrieve the upper boundary
 */
publicPointgetUpperRightVertex()
 {
returnupperRightVertex;
 }

/**
 * Set the upper boundary using a Point
 */
publicvoidsetUpperRightVertex(Pointu)
 {
upperRightVertex = u;
 }

/**
 * Set the upper boundary using the x, y, and z
 * components
 */
publicvoidsetUpperRightVertex(doublex, doubley, doublez)
 {
upperRightVertex.x = x;
upperRightVertex.y = y;
upperRightVertex.z = z;
 }

/**
 * Merge two bounding boxes, taking the
 * largest values for each of x, y, and z
 */
publicvoidmerge(BoundingBoxother)
 {
upperRightVertex.x = Math.max(this.upperRightVertex.x,
other.upperRightVertex.x);

upperRightVertex.y = Math.max(this.upperRightVertex.y,
other.upperRightVertex.y);

upperRightVertex.z = Math.max(this.upperRightVertex.z,
other.upperRightVertex.z);
 }

/**
 * Apply a scaling factor
 */
publicvoidscale(doubles)
 {
upperRightVertex.scale(s);
 }
}