Ejemplo n.º 1
0
    def test_get_intersect(self):

        S = Sphere(Vector(5.0, 0.0, 0.0))
        self.assertEqual(
            S.get_intersect(Vector(0.0, 0.0, 0.0), Vector(1.0, 0.0, 0.0)), 4.0)

        S = Sphere(Vector(5, 0.0, -1.0))
        t = S.get_intersect(Vector(0.0, 0.0, 0.0), Vector(1.0, 0.0, 0.0))
        self.assertTrue((5.0 - abs(t)) <= 0.0001)
Ejemplo n.º 2
0
 def loadObjects(self):
     print("____Load standard Objects____")
     self.objects = [
         Sphere(np.array([0, 5, 1]), 1, self.rot),
         Sphere(np.array([-1.5, 2, 1]), 1, self.gruen),
         Sphere(np.array([1.5, 2, 1]), 1, self.blau),
         Plane(np.array([0, -2, 5]), np.array([0, 1, 0]), self.grey),
         Rectangle(np.array([-1.5, 2, 1]), np.array([1.5, 2, 1]),
                   np.array([0, 5, 1]), self.gelb)
     ]
Ejemplo n.º 3
0
    def calculateSphere(self, problems: dict) -> dict:

        S = Sphere()
        solutionDict = {}

        for key in list(problems.keys()):
            task = problems[key]
            valueType = next(iter(task.keys()))
            value = next(iter(task.values()))

            if valueType == 'r':
                S.radius = value

            elif valueType == 'Ao':
                S.Ao = value

            elif valueType == 'ERROR':
                S.error = True

            else:
                S.volume = value

            solutionDict[key] = S.getValues()

        return solutionDict
Ejemplo n.º 4
0
class ShapeTester:
    print('welcome to Shape Tester')
    print('Please choose \'box\', \'pyramid\', or \'sphere\'')
    while True:
        shape = input('>')
        if shape == 'box':
            print('You Chose Box')
            width = int(input('choose a width: '))
            height = int(input('choose a height: '))
            length = int(input('choose a length: '))
            b1 = Box(length, width, height)
            print('The Volume is: %f' % b1.getVolume())
            print('The Surface Area is %f' % b1.getSurfArea())
        elif shape == 'pyramid':
            print('You Chose Pyramid')
            width = int(input('choose a width: '))
            height = int(input('choose a height: '))
            length = int(input('choose a length: '))
            p1 = Pyramid(length, width, height)
            print('The Volume is: %f' % p1.getVolume())
            print('The Surface Area is %f' % p1.getSurfArea())
        elif shape == 'sphere':
            print('You Chose Sphere')
            radius = int(input('choose a radius: '))
            s1 = Sphere(radius)
            print('The Volume is: %f' % s1.getVolume())
            print('The Surface Area is: %f' % s1.getSurfArea())
        else:
            print('incorrect syntax try again')
Ejemplo n.º 5
0
class ShapeTester:
    print('Welcome to the Shape Tester')
    print('Please type \'Box\', \'Sphere\', or \'Pyramid\'')
    while True
    i= input('>')
    if i == 'Box':
        print('Alright, let us start with a box.')
        width= int(input("Please enter a width:"))
        length= int(input("Please input a length: "))
        height= int(input("Please input a height: "))
        b1=Box(width,length,height)
        print('Volume: %s' % b1.getVolume())
        print('Surface Area: %s' % b1.getSA())
    elif i == 'Sphere':
        print('Alright, let us start with a sphere.')
        radius = int(input("Please enter a radius: "))
        s1=Sphere(radius)
        print('Volume: %s' % s1.getVolume())
        print('Surface Area: %s' % s1.getSA())
    elif i == 'Pyramid':
        print('Alright, let us start with a pyramid.')
        width= int(input("Please enter a width:"))
        length= int(input("Please input a length: "))
        height= int(input("Please input a height: "))
        p1=Pyramid(length,width,height)
        print('Volume: %s' % p1.getVolume())
        print('Surface Area: %s' % p1.getSA())
    else:
        print('mmmmmmm, try again.')
Ejemplo n.º 6
0
def randomSphereScene():
	world = HitableList()

	# Bottom "plane"
	world.add(Sphere(Vec3(0,-1000,0), 1000, Lambertian(Vec3(0.5, 0.5, 0.5))))

	# three large spheres
	world.add(Sphere(Vec3(0, 1, 0), 1.0, Dielectric(1.5)))
	world.add(Sphere(Vec3(-4, 1, 0), 1.0, Lambertian(Vec3(0.4, 0.2, 0.1))))
	world.add(Sphere(Vec3(4, 1, 0), 1.0, Metal(Vec3(0.7, 0.6, 0.5), 0.0)))

	# numerous small spheres
	i = 1
	for a in range(-11, 11):
		for b in range(-11, 11):
			chooseMat = random.random()
			center = Vec3(a + 0.9*random.random(), 0.2, b + 0.9*random.uniform(0,1))
			if (center - Vec3(4, 0.2, 0)).length() > 0.9:
				if chooseMat < 0.8:
					# diffuse
					albedo = Vec3.random() * Vec3.random()
					world.add(Sphere(center, 0.2, Lambertian(albedo)))
				elif chooseMat < 0.95:
					# metal
					albedo = random.uniform(.5, 1)
					fuzz = random.uniform(0, .5)
					world.add(Sphere(center, 0.2, Metal(albedo, fuzz)))
				else:
					# glass
					world.add(Sphere(center, 0.2, Dielectric(1.5)))

	return world
Ejemplo n.º 7
0
def load_sphere(line_group):
    """ Reads data from source and creates a Sphere object """
    global shape_list
    position = [float(x) for x in line_group[0].split()]
    radius = [float(x) for x in line_group[1].split()]
    radius = radius[0]
    opacity = [float(x) for x in line_group[2].split()]
    color = [float(x) for x in line_group[3].split()]
    sphere = Sphere(position, radius, opacity, color)
    shape_list.append(sphere)
    print "sphere created"
Ejemplo n.º 8
0
 def addSphere(self):
     #Adds a renderobject from proper data, if the data is not proper, the program will not do anything
     d = self.getData()
     if len(d) == 0:
         messagebox.showerror(
             "Error", "A value-error has appeared. Enter proper values")
     else:
         rnge = d[6]
         rgb = [d[7], d[8], d[9]]
         sphere = Sphere(d[0], d[1], d[2], d[3])
         renderObj = TkinterRender(self.__mainCanvas, sphere, d[4], d[5],
                                   rgb, rnge)
         self.__renderObjects.append(renderObj)
     self.objectSetup()
 def init_spheres(self):
     for s in range(len(self.spheres)):
         random_position = glm.vec3([
             random.random() - 0.5,
             random.random() - 0.5,
             random.random() - 0.5
         ]) * 7500.0
         random_radius = 200 + (800 * random.random())
         random_color = glm.vec3(
             [random.random(),
              random.random(),
              random.random()])
         random_opacity = random.random()
         self.spheres[s] = (Sphere(random_position, random_radius,
                                   random_color, random_opacity))
Ejemplo n.º 10
0
 def __init__(self, width, height):
     self.width = width
     self.height = height
     self.eye_x = self.eye_y = self.eye_z = 0
     self.radius = 100
     self.phi = 0.0
     self.theta = 90.0
     self.up_x = 0
     self.up_y = 1
     self.up_z = 0
     self.scale = 1
     self.surface = Surface(lambda x, y: 50 *
                            (sin(x * pi / 180) + cos(y * pi / 180)))
     self.light = Light()
     self.cube = Cube(10)
     self.sphere = Sphere(20)
     self.enable_light_source = True
Ejemplo n.º 11
0
 def __init__(self,
              coordinates=None,
              particle=None,
              instrument=None,
              **kwargs):
     '''
     Keywords
     ----------
     coordinates : numpy.ndarray
        [3, npts] array of x, y and z coordinates where field
        is calculated
     particle : Particle
        Object representing the particle. Default: Sphere()
     instrument : Instrument
        Object resprenting the light-scattering instrument
     '''
     self.coordinates = coordinates
     self.particle = particle or Sphere(**kwargs)
     self.instrument = instrument or Instrument(**kwargs)
Ejemplo n.º 12
0
def _sphere_with_values(self, name):
    s = Sphere()
    # TODO: feels like we should have a generic function for parsing
    # gherkin tables
    digit = re.compile(r'^[-+]?\d*\.?\d+$')
    tuple3 = re.compile(r'^\([-+]?\d*\.?\d+\s*,\s*[-+]?\d*\.?\d+\s*,\s*'
                        r'[-+]?\d*\.?\d+\)$')
    subattr = re.compile(r'.*\..*')
    scaling = re.compile(r'^scaling\([-+]?\d*\.?\d+\s*,\s*[-+]?\d*\.?\d+\s*,'
                         r'\s*[-+]?\d*\.?\d+\)$')
    for row in self.table:
        attr = str(row[0])
        obj = s
        print(obj, attr)
        while subattr.match(attr):
            print(attr.split('.'))
            obj = getattr(obj, attr.split('.', 2)[0])
            attr = attr.split('.', 2)[1]
            print(obj, attr)
        value = row[1]
        if digit.match(value):
            print("DIGIT", attr, float(value))
            setattr(obj, attr, float(value))
        if tuple3.match(value):
            values = value.replace("(", "").replace(")", "").split(',')
            print("TUPLE3", attr, float(values[0]), float(values[1]),
                  float(values[2]))
            setattr(
                obj, attr,
                Colour(float(values[0]), float(values[1]), float(values[2])))
        if scaling.match(value):
            values = value.split('(')[1].replace("(", "").replace(")", "").\
                split(',')
            print(
                "SCALING", attr,
                Transformation.Scaling(float(values[0]), float(values[1]),
                                       float(values[2])))
            setattr(
                obj, attr,
                Transformation.Scaling(float(values[0]), float(values[1]),
                                       float(values[2])))
    setattr(world, name, s)
Ejemplo n.º 13
0
    def sphere(self):
        print 'Type in the variable you already know.'
        try:
            self.r = float(raw_input('r = '))
        except (ValueError):
            self.r = 0

        try:
            self.d = float(raw_input('d = '))
        except (ValueError):
            self.d = 0

        try:
            self.V = float(raw_input('V = '))
        except (ValueError):
            self.V = 0

        try:
            self.M = float(raw_input('O = '))
        except (ValueError):
            self.M = 0

        try:
            self.U = float(raw_input('U = '))
        except (ValueError):
            self.U = 0

        variables = {}
        if self.r != 0:
            variables['r'] = self.r
        if self.d != 0:
            variables['d'] = self.d
        if self.V != 0:
            variables['V'] = self.V
        if self.M != 0:
            variables['O'] = self.M
        if self.U != 0:
            variables['U'] = self.U

        return Sphere(variables)
Ejemplo n.º 14
0
def Refraction(ray, air_ind, glass_ind, env="air"):
    sphere = Sphere(position=Vector(2, 2, 2), radius=1.0)
    print "ray.ray_origin", ray.origin
    print "ray.ray_dir", ray.ray_dir
    t_min = sphere.get_intersect(ray_origin=ray.origin,
                                 ray_dir=ray.ray_dir.normalize())
    print "t_min", t_min
    intersect_point = ray.origin.clone().add(
        (ray.ray_dir.normalize().clone()).constant_multiply(t_min * 0.001))
    print "intersect_point", intersect_point
    normal_vector = sphere.surface_normal(point=intersect_point.clone(),
                                          ray_origin=ray.origin.clone(),
                                          ray_dir=ray.ray_dir.clone())
    print "normal_vector", normal_vector
    c_1 = normal_vector.normalize().clone().dot(
        ray.ray_dir.normalize().clone())
    if env == "air":
        n = air_ind / glass_ind
        c_1 = -c_1
        print "n", n
        # print "c_1", c_1
    else:
        n = glass_ind / air_ind
        print "n", n
        normal_vector = normal_vector.normalize().constant_multiply(-1)
    k = (1 - (n**2) * (1 - (c_1)**2))
    if k < 0:
        return "K is negative"
    c_2 = math.sqrt(k)
    part_1 = ray.ray_dir.normalize().constant_multiply(n)
    part_2 = normal_vector.normalize().clone().constant_multiply(
        (n * c_1 - c_2))
    ref_ray_dir = (part_1.clone().add(part_2.clone())).normalize()
    # print "ref_ray_dir", ref_ray_dir
    ref_ray = Ray(origin=intersect_point, ray_dir=ref_ray_dir)
    # print "env", env
    # print "n", n
    return ref_ray
Ejemplo n.º 15
0
class ShapeTester:
    print('Welcome to ShapeTester')
    while True:
        print('Please choose \'box\', \'pyramid\', or \'sphere\'')
        width = 0
        length = 0
        height = 0
        radius = 0
        t = input('>')
        if t == 'box':
            print('You chose \'box\'!')
            width = int(input('Choose a width: '))
            length = int(input('Choose a length: '))
            height = int(input('Choose a height: '))
            b1 = Box(length, width, height)
            print('Volume: %f' % b1.getVolume())
            print('Surface Area: %f' % b1.getSurf())

        elif t == 'pyramid':
            print('You chose \'pyramid\'!')
            length = int(input('Choose length: '))
            width = int(input('Choose width: '))
            height = int(input('Choose height of pyramid: '))
            p1 = Pyramid(length, width, height)
            print('Volume: %f' % p1.getVolume())
            print('Surface Area: %f' % p1.getSurf())

        elif t == 'sphere':
            print('You chose \'sphere\'!')
            radius = int(input('Chose radius: '))
            s1 = Sphere(radius)
            print('Volume: %f' % s1.getVolume())
            print('Surface Area: %f' % s1.getSurf())
            print('Circumference: %f' % s1.getCircum())
        else:
            print('Incorrect syntax, try again')
Ejemplo n.º 16
0
            self.camera.direction = self.camera.direction.modulus_add(Vector(0, 0.08, 0),
                                                                      Vector(2 * pi, 2 * pi, 2 * pi))
            print(self.camera.direction)
        if 's' in pressed_keys:
            self.camera.direction = self.camera.direction.modulus_add(Vector(0, -0.08, 0),
                                                                      Vector(2 * pi, 2 * pi, 2 * pi))
        if 'Up' in pressed_keys:
            self


def on_key_press(event):
    pressed_keys.add(event.keysym)


def on_key_release(event):
    pressed_keys.remove(event.keysym)


s = Scene(1500, 800, master=tk.Tk())
objects = [(Sphere(2, 7, 0, 3), (70, 0,0))]

while True:
    start_time = int(round(time.time() * 1000))
    s.draw_vision(objects)
    s.apply_user_input()
    s.update()
    end_time = int(round(time.time() * 1000))
    print(end_time - start_time)
    if 60 > end_time - start_time:
        time.sleep((60 - end_time + start_time) / 1000)
Ejemplo n.º 17
0

if __name__ == '__main__':
    from Sphere import Sphere
    import matplotlib.pyplot as plt

    # Create coordinate grid for image
    x = np.arange(0, 201)
    y = np.arange(0, 201)
    xv, yv = np.meshgrid(x, y)
    xv = xv.flatten()
    yv = yv.flatten()
    zv = np.zeros_like(xv)
    coordinates = np.stack((xv, yv, zv))
    # Place a sphere in the field of view, above the focal plane
    particle = Sphere()
    particle.r_p = [125, 75, 100]
    particle.a_p = 0.5
    particle.n_p = 1.45
    # Form image with default instrument
    instrument = Instrument()
    instrument.magnification = 0.135
    instrument.wavelength = 0.447
    instrument.n_m = 1.335
    k = instrument.wavenumber()
    # Use Generalized Lorenz-Mie theory to compute field
    kernel = GeneralizedLorenzMie(coordinates, particle, instrument)
    field = kernel.field()
    # Compute hologram from field and show it
    field *= np.exp(-1.j * k * particle.z_p)
    field[0, :] += 1.
Ejemplo n.º 18
0
f = hf.normalize((np.subtract(c, e)))  #z coordinate
s = hf.normalize(np.cross(f, up))  #x coordiante
u = np.cross(s, f)  #y coordinate

#intern camera parameters
alpha = np.deg2rad(FOV) / 2.0
viewheight = 2 * np.tan(alpha)  #heigth of viewport
viewWidth = ASPRATIO * viewheight  #width of viewport

pixelWidth = viewWidth / WIDTH  #width of a pixel
pixelHeigth = viewheight / HEIGHT  #height of a pixel
"""init scene"""
objectList = []
if MODE == 6:
    objectList.append(
        Sphere(hf.cVector(0, 5, 20), 2,
               mat(hf.cVector(0, 0, 255), 32, 1, 0.7, 0.1)))
    objectList.append(
        Sphere(hf.cVector(-1, 1, 5), 0.2,
               mat(hf.cVector(255, 100, 0), 1, 0.2, 0.3, 0.4)))
    objectList.append(
        Sphere(hf.cVector(-1, -4, 3), 1,
               mat(hf.cVector(255, 70, 30), 1, 0.2, 0.3, 0.4)))
    objectList.append(
        Sphere(hf.cVector(-1, 1, 2), 0.2,
               mat(hf.cVector(30, 240, 24), 1, 0.2, 0.3, 0.4)))
    objectList.append(
        Sphere(hf.cVector(4, 2, 10), 3,
               mat(hf.cVector(100, 0, 255), 20, 0.6, 0.9, 0.1)))
    objectList.append(
        Triangle(hf.cVector(1, 4, 20), hf.cVector(3, -6, 20),
                 hf.cVector(-2.5, -2, 20),
Ejemplo n.º 19
0
from Sphere import Sphere
from Cuboid import Cuboid

radius = int(input())
scolor = str(input())
l = float(input())
w = float(input())
h = float(input())
ccolor = str(input())

sphere = Sphere(radius)
sphere.setColor(scolor)

cuboid = Cuboid(l, w, h)
cuboid.setColor(ccolor)

print("{}({}),{},{}".format(sphere.__str__(), sphere.getRadius(),
                            round(sphere.getVolume(), 1), sphere.getColor()))
print("{}({},{},{}),{},{}".format(cuboid.__str__(), int(cuboid.getLength()),
                                  int(cuboid.getWidth()),
                                  int(cuboid.getHeight()),
                                  round(cuboid.getVolume(), 1),
                                  cuboid.getColor()))
Ejemplo n.º 20
0
measure = input("What shape do you want? \n1. Box \n2. Sphere \n3. Pyramid \n")

if measure == 1:
    l = input("What is the length: ")
    h = input("What is the height: ")
    w = input("What is the width: ")
    #print ("Box mode has been selected.")
    #box1 = Box(4, 2000, 2)
    box1.displayBox()
    box1.calcVal()
    box1.calcSur

if measure == 2:
    r = input("What is the radius: ")
    sphere1 = Sphere(r)
    sphere1.displaySphere()
    sphere1.calcVol()
    sphere1.calcSur()

if measure == 3:
    l = input("What is the length: ")
    h = input("What is the height: ")
    w = input("What is the width: ")
    pyramid1 = Pyramid(l, h, w)
    pyramid1.displayPyramid()
    pyramid1.calcVol()
    pyramid1.calcSur()

else:
    print "Type the numbers 1, 2, or 3 next time"
Ejemplo n.º 21
0
from Shape import Shape
from Cuboid import Cuboid
from Sphere import Sphere

#main

inp = []
for i in range(6):
    inp.append(input())

sphere = Sphere(int(inp[0]), inp[1])
cubiod = Cuboid(int(inp[2]), int(inp[3]), int(inp[4]), inp[5])

print("{}:({}),{},{}".format(str(sphere), sphere.getRadius(),
                             sphere.getVolume(), sphere.getColor()))
print("{}:({},{},{}),{},{}".format(str(cubiod), cubiod.getLength(),
                                   cubiod.getWidth(), cubiod.getHeight(),
                                   cubiod.getVolume(), cubiod.getColor()))
Ejemplo n.º 22
0
    def __init__(self,
                 blobFileName,
                 garnetProfile,
                 rockCompo,
                 rockVolume,
                 sampleName,
                 numBins=0):

        self.composition = rockCompo  #This is a list of ComponentMol objects that define the rock composition
        self.grtProfile = garnetProfile  #This is the CompoProfile object that is a half profile that defines the zoning in the garnet
        self.rockVol = rockVolume
        #Now need to open up the blob file to build the crystal list
        blobDF = pd.read_excel(
            blobFileName
        )  #Assumes that formatting has not changed from default blob output
        self.name = sampleName
        self.crystalList = []  #Empty list to fill with Shape entries

        blobDF = blobDF.dropna(
        )  #Sometimes empty rows at the end mess up calculations

        #Choose temperature and pressure range:
        title = "PT range"
        msg = "Please provide min and max temperature and pressure"

        fieldNames = ["Tmin", "Tmax", "Pmin", "Pmax"]

        fieldValues = easygui.multenterbox(msg, title, fieldNames)
        # make sure that none of the fields was left blank
        # Gotta make things a little bit idiot proof
        while 1:
            if fieldValues == None: break
            errmsg = ""
            for i in range(len(fieldNames)):
                if fieldValues[i].strip() == "":
                    errmsg = errmsg + ('"%s" is a required field.\n\n' %
                                       fieldNames[i])
            if errmsg == "": break  # no problems found
            fieldValues = multenterbox(errmsg, title, fieldNames, fieldValues)

        self.T1 = int(fieldValues[0].strip())
        self.T2 = int(fieldValues[1].strip())
        self.P1 = int(fieldValues[2].strip())
        self.P2 = int(fieldValues[3].strip())

        #Ask user to choose if using spheres or ellipsoids
        msg = "Are garnets spheres or ellipsoids?"
        title = ""
        choices = ["Sphere", "Ellipsoid"]
        reply = "Sphere"  #Ellipsoid doesnt do much atm
        # reply = easygui.buttonbox(msg,title,choices)
        #reply = "Sphere" #Only works for Spheres right now, need to think about size independent growth of ellipsoids
        if (reply == choices[0]):
            volume = list(blobDF['Volume (mm^3)'])

            for i in range(len(volume)):
                #If spheres, it will recalculate the radius from the volume
                #if not math.isnan(volume[i]):
                thisRad = (volume[i] * 3 / (4 * math.pi))**(1. / 3)
                self.crystalList.append(Sphere(thisRad))

        elif (reply == choices[1]):
            #If ellipsoid it uses the PEllipsoid data
            # #It should be that rad1 > rad2 > rad3
            # rad1 = list(blobDF['PEllipsoid Rad1 (mm)'])
            # rad2 = list(blobDF['PEllipsoid Rad2 (mm)'])
            # rad3 = list(blobDF['PEllipsoid Rad3 (mm)'])

            # for i in range(len(rad1)):
            # 	if not math.isnan(rad1[i]):
            # 		self.crystalList.append(Ellipsoid(rad1[i],rad2[i],rad3[i]))

            #Average out the ratios so all ellipsoids are the same shape and grow with the same dimensions
            avgEllipsoid = self.getAvgEllipsoid(blobDF)
            volume = list(blobDF['Volume (mm^3)'])

            for i in range(len(volume)):
                #Need to rescale the avg ellipsoid to fit the volume of each garnet
                #if not math.isnan(volume[i]):
                ratioAB = avgEllipsoid.aAx / avgEllipsoid.bAx
                ratioBC = avgEllipsoid.bAx / avgEllipsoid.cAx
                thisA = ((3 * ratioAB**2 * ratioBC * volume[i]) /
                         (math.pi * 4))**(1 / 3)
                thisB = thisA / ratioAB
                thisC = thisB / ratioBC

                self.crystalList.append(Ellipsoid(thisA, thisB, thisC))
        else:
            print("Error: No option chosen")
            return

        #Okay now we need to stretch the garnet profile to fit with the long dimension of the ellipsoid or the radius of the sphere
        #This is so the profile matches up with the biggest garnet

        self.quickSortCrystals(0, len(self.crystalList) - 1)
        self.numCrystals = []

        #Added support for binning but I dont think its needed
        #Still the code is here
        if (numBins > 0):
            #Break things up into seperate bins
            binSize = (
                self.crystalList[0].getDim() -
                self.crystalList[len(self.crystalList) - 1].getDim()) / numBins
            newCrystalList = []

            hiBin = self.crystalList[0].getDim()
            #make new crystalList with a crystalSize equal to he highest radius in that bin interval
            for i in range(numBins):
                thisInterval = hiBin - i * binSize  #each value in bins represent the upperbounds of that bin
                nextInterval = hiBin - (i + 1) * binSize
                numInBin = 0
                biggestInBin = Sphere(0)
                for crystal in self.crystalList:
                    if crystal.getDim() <= thisInterval and crystal.getDim(
                    ) > nextInterval:
                        numInBin += 1
                        if crystal.getDim() > biggestInBin.getDim():
                            biggestInBin = crystal
                            #the biggest in the bin is the crystal that gets put in the new crystalList
                if numInBin > 0:
                    newCrystalList.append(biggestInBin)
                    self.numCrystals.append(numInBin)

            self.crystalList = newCrystalList

        travRad = max(
            self.grtProfile.x
        )  #Radius of the garnet measured in the microprobe profile

        minDiff = sys.float_info.max
        # for i in range (len(self.crystalList) - 1):
        # 	radDiff = self.crystalList[i].getDim()-self.crystalList[i+1].getDim()
        # 	if radDiff > 0:
        # 		minDiff = min(radDiff,minDiff)
        #This makes sure that a shell is not bigger than the difference in radius between any two garnets
        self.shellThick = min(minDiff,
                              self.crystalList[0].getDim() / NUM_SHELLS)

        #Instead of stretching, lets try extrapolating the core inwards:
        radAdd = self.crystalList[0].getDim() - travRad
        msg = "Extrapolate to core or stretch profile?"
        title = ""
        choices = ["Extrapolate", "Stretch"]
        reply = easygui.buttonbox(msg, title, choices)
        if radAdd > 0 and reply == choices[
                0]:  #In case the biggest garnet has a radius smaller than traverse length
            self.grtProfile.extrapCore(CORE_AVG_INDEX, radAdd)
        else:
            scaleFactor = self.crystalList[0].getDim(
            ) / travRad  #The scaling factor to convert the x values in grtProfile to be the same size as the radius or a axis of ellipsoid

            for i in range(len(self.grtProfile.x)):
                #Rescale x
                self.grtProfile.x[i] = scaleFactor * self.grtProfile.x[i]

        self.grtProfile.scipyInterp(
        )  #Initialize the interpolated numpy arrays

        self.garnetList = [
        ]  #This is what we will be working with for the most part, it is where all the garnets will grow and be stored
Ejemplo n.º 23
0
def main():
    try:
        fps = 50
        surface = pygame.display.set_mode((600, 600))
        pygame.init()
        origin = (surface.get_width() / 2, surface.get_height() / 2)
        theta = 1
        step = math.pi / 180
        center_x = surface.get_width() / 2
        center_y = surface.get_height() / 2
        # Cube( surface, color, center3d, size)
        spheres = (
            Fire(surface, pygame.Rect(100, 100, 400, 200), 2),
            Sphere(surface, (100, 0, 0), Vec3d(-1.5, -1.5, -1.5),
                   Vec3d(1, 1, 1)),
            #Sphere(surface, (100, 0, 0), Vec3d(0, 0, 0), Vec3d(1, 1, 1)),
            #Sphere(surface, (100, 0, 0), Vec3d(1.5, 1.5, 1.5), Vec3d(1, 1, 1)),
            Circle(surface, (100, 0, 0), Vec3d(1.5, -1.5, -1.5),
                   Vec3d(1, 1, 1)),
            Tree(surface, pygame.Color(0, 100, 100), Vec2d(300, 500), 5, 50),
            Tree(surface, pygame.Color(0, 100, 100), Vec2d(330, 500), 5, 100),
            Starfield(surface, stars=100, depth=10),
            InfoRenderer(surface,
                         pygame.Color(0, 255, 0),
                         pos=Vec2d(100, 100),
                         size=10),
            ScrollText(surface, "Dolor Ipsum Dolor uswef", 400,
                       pygame.Color(255, 255, 0)),
            SinusText(surface, "Dolor Ipsum Dolor uswef", 200, 30, 2,
                      pygame.Color(0, 255, 255)),
        )
        clock = pygame.time.Clock()

        size_angle = 0
        size_angle_step = math.pi / 720
        cg = ColorGradient(0.0, 0.05, 0.05)
        background_gradient = GradientBackground(surface)
        # for 3d projection
        fov = 2
        viewer_distance = 256
        pause = False
        while True:
            clock.tick(fps)
            events = pygame.event.get()
            for event in events:
                if event.type == pygame.QUIT:
                    sys.exit(0)
            keyinput = pygame.key.get_pressed()
            if keyinput is not None:
                # print keyinput
                if keyinput[pygame.K_ESCAPE]:
                    sys.exit(1)
                #if keyinput[pygame.K_z]:
                #    theta[2] += math.pi / 180
                #if keyinput[pygame.KMOD_SHIFT | pygame.K_z]:
                #    theta[2] -= math.pi / 180
                #if keyinput[pygame.K_x]:
                #    theta[0] += math.pi / 180
                #if keyinput[pygame.KMOD_SHIFT | pygame.K_x]:
                #    theta[0] -= math.pi / 180
                #if keyinput[pygame.K_y]:
                #    theta[1] += math.pi / 180
                #if keyinput[pygame.KMOD_SHIFT | pygame.K_y]:
                #    theta[1] -= math.pi / 180
                if keyinput[pygame.K_UP]:
                    viewer_distance += 1
                if keyinput[pygame.K_DOWN]:
                    viewer_distance -= 1
                if keyinput[pygame.K_PLUS]:
                    fov += .1
                if keyinput[pygame.K_MINUS]:
                    fov -= .1
                if keyinput[pygame.K_p]:
                    pause = not pause
                if keyinput[pygame.K_r]:
                    viewer_distance = 256
                    fov = 2
            if pause is not True:
                surface.fill((0, 0, 0, 255))
                background_gradient.update()
                for thing in spheres:
                    if type(thing) == InfoRenderer:
                        thing.update(lines=("viewer_distance : %f" %
                                            viewer_distance, "fov: %f" % fov))
                        continue
                    elif type(thing) == Tree:
                        thing.update()
                        continue
                    elif type(thing) in (
                            Sphere,
                            Circle,
                    ):
                        # rotate
                        thing.rotate(dx=theta,
                                     dy=theta,
                                     dz=0.0,
                                     offset2d=Vec2d(0, 0))
                        theta += step * 16
                        # color changing
                        color = cg.get_color()
                        thing.set_color(color=color)
                        # size wobbling
                        # size_angle += size_angle_step
                        # thing.set_size(0.5 + math.sin(size_angle) * 0.125)
                        # draw
                        thing.update(viewer_distance=viewer_distance, fov=fov)
                        continue
                    elif type(thing) in (
                            SinusText,
                            ScrollText,
                    ):
                        thing.update()
                    elif type(thing) == Tree:
                        thing.update(center=Vec2d(0, 0),
                                     viewer_distance=viewer_distance,
                                     fov=fov)
                    else:
                        thing.update()
                pygame.display.flip()
    except KeyboardInterrupt:
        print('shutting down')
Ejemplo n.º 24
0
sphereRadius = .5
sphereMaterialColor = Vector(255, 255, 255)
sphere2MaterialColor = Vector(0,255,255)
sphereMaterialSpecularColor = Vector(0, 255, 255)
sphereMaterialSpecularStrength = .5

sphereMaterial = Material(
    sphere2MaterialColor, sphereMaterialSpecularColor, sphereMaterialSpecularStrength,.0)

sphereMaterial2 = Material(
    Vector(64, 64, 64), sphereMaterialSpecularColor, sphereMaterialSpecularStrength, .5)

#sphereMaterial3 = Material(
    #Vector(0, 255, 0), sphereMaterialSpecularColor, sphereMaterialSpecularStrength, 0)

sphere = Sphere(sphereMaterial2, sphereCenter, sphereRadius)
#sphere2 = Sphere(sphereMaterial, Point3D(.2, .2, .5), .1)
#sphere3 = Sphere(sphereMaterial2, Point3D(-.2, -.1, .5), .1)
#sphere4 = Sphere(sphereMaterial3, Point3D(0, -.1, .5), .1)

lights = [light, light3]
objects = [sphere]
#objects = [sphere, sphere2, sphere3, sphere4]
#Now loop over every pixel in our frame

#For every pixel
#Figure out where in camera space that pixel is
#Then figure out where in world space that pixel is
#Then shoot a ray from the world space origin of the camera to that world space location
#Then loop over each object in the scene
#For ever object that ray collides with
Ejemplo n.º 25
0
BACKGROUND_COLOR = (0,0,0)
CHECKERBOARD = CheckerboardMaterial(0,0,0)

image = Image.new('RGB', (IMAGE_WIDTH,IMAGE_HEIGHT))

"""---Kamera-Settings---"""
e = numpy.array([0,1.8,10])
c = numpy.array([0,3,0])
up = numpy.array([0,1,0]) #UP Vektor in Minusbereich dreht das Eichhörnchen
fieldOfView = 45

camera = Camera(e,c,up,fieldOfView)


"""---Objekte für die Szene. render_squirrel() verwenden um das Eichhörnchen zu rendern---"""
redSphere = Sphere(numpy.array([2.5,6.5,-15]),2.1,(250,0,0))
greenSphere = Sphere(numpy.array([-2.5,6.5,-15]),2.1,(0,250,0))
blueSphere = Sphere(numpy.array([0,2,-15]),2.1,(0,0,250))
triangle = Triangle(numpy.array([2.5,6.5,-15]), numpy.array([-2.5, 6.5, -15]), numpy.array([0,2,-15]),(255,255,0))
plane = Plane(numpy.array([0, 10, 0]), numpy.array([0, -10, -2]),CHECKERBOARD)

objectlist = [redSphere, greenSphere, blueSphere,triangle, plane]
light = Light(numpy.array([30,-30,10]),(255,255,255))

maxlevel = 1

"""---Phong spezifische Settings---"""
shadow_ambient = 0.1
no_shadow_ambient = 0.5
diffusion = 0.5
specular = 0.5
Ejemplo n.º 26
0
def _sphere(self, name):
    setattr(world, name, Sphere())
Ejemplo n.º 27
0
from Sphere import Sphere
from Cuboid import Cuboid

spRadius = float(input())
spColor = str(input())

cuLength = float(input())
cuWidth = float(input())
cuHeight = float(input())
cuColor = str(input())

sp = Sphere(spRadius, spColor)
cu = Cuboid(cuLength, cuWidth, cuHeight, cuColor)

print(
    str(sp) + ":(%d),%.1f,%s" %
    (sp.getRadius(), sp.getVolume(), sp.getColor()))
print(
    str(cu) + ":(%d,%d,%d),%.1f,%s" %
    (cu.getLength(), cu.getWidth(), cu.getHeight(), cu.getVolume(),
     cu.getColor()))
Ejemplo n.º 28
0
from Vector import Vector
from Ray import Ray
from Triangle import Triangle
from Sphere import Sphere
from Triangle import Triangle
from Screen2D import Screen2D
from Viewport import Viewport
from PointLight import PointLight
import math
import sys

ray = Ray(origin=Vector(0.0, 0.0, 0.0), ray_dir=Vector(1.0, 1.0, 0.5))
sphere = Sphere(position=Vector(2, 2, 2), radius=1.0)
t_min = sphere.get_intersect(ray_origin=Vector(0.0, 0.0, 0.0),
                             ray_dir=Vector(1.0, 1.0, 0.5))
print t_min
intersect_point = ray.origin.clone().add(
    ray.ray_dir.clone().constant_multiply(t_min))
normal_vector = sphere.surface_normal(point=intersect_point.clone(),
                                      ray_origin=ray.origin.clone(),
                                      ray_dir=ray.ray_dir.clone())
# print "normal_vector", normal_vector
# print "ray_dir", ray.ray_dir
# print "ray_dir_normalize", ray.ray_dir.normalize()
# print "intersect_point", intersect_point


def Refraction(ray, air_ind, glass_ind, env="air"):
    sphere = Sphere(position=Vector(2, 2, 2), radius=1.0)
    print "ray.ray_origin", ray.origin
    print "ray.ray_dir", ray.ray_dir
Ejemplo n.º 29
0
ray = Ray(np.array([0.0, 0.0, 0.0]), np.array([0.0, 0.0, -1.0]))

point = np.array([0.0, -10.0, 0.0])
normal = np.array([0.0, -1.0, 0.0])
p = Plane(point, normal, np.array([1.0, 1.0, 1.0]), 1.0, 1.0, 0.05, 150, 0.6,
          "plane1")
tree.insert(p)
radius = 3
center = np.array([-10.0, -7.0, -17.0])
s = Sphere(radius,
           center,
           np.array([0.289, 0.2845, 0.3779]),
           1.0,
           1.0,
           1.0,
           4,
           0.0,
           "sphere1",
           noise=True,
           priori1=np.array([0.8, 0.6, 1.0]),
           priori2=np.array([1.0, 1.0, 1.0]),
           noisyText="noisetext.png")
tree.insert(s)

center = np.array([3.0, -7.0, -17.0])
s1 = Sphere(radius,
            center,
            np.array([0.289, 0.2845, 0.3779]),
            1.0,
            1.0,
            1.0,
Ejemplo n.º 30
0
def sphere(radius):
    from Sphere import Sphere
    return Sphere(radius)