.gitignore

@@ -1,5 +0,0 @@
-__pycache__/graph.cpython-312.pyc
-__pycache__/particle.cpython-312.pyc
-
-__pycache__/sensor.cpython-312.pyc
-__pycache__/slider.cpython-312.pyc

graph.py

@@ -1,26 +0,0 @@
-import pygame
-
-class Graph:
-	def __init__(self, ratio, max_time, center, y_scale):
-		self.ratio = ratio
-		self.max_time = max_time
-		self.center = center
-		self.y_scale = y_scale
-		self.data = []
-
-	def draw(self, screen, x, y, time_scale):
-		rect = pygame.Rect(0, 0, x, y / self.ratio)
-		pygame.draw.rect(screen, (0,0,0), rect)
-		self.draw_data(x, y, screen, time_scale)
-
-	def add_data(self, time, value):
-		self.data.append([time, value])
-
-	def get_data(self):
-		return self.data
-
-	def draw_data(self, x, y, screen, time_scale):
-		offset = 0
-		for i in range(len(self.data) - 1, -1, -1):
-			pygame.draw.circle(screen, (255,0,0), (x - offset ,(y / (2 * self.ratio)) + self.data[i][1] * 10), 1)
-			offset += time_scale * 10

newMain.py

@@ -5,21 +5,13 @@ import math
 from sensor import Sensor
 from particle import Particle
 from slider import Slider
-from graph import Graph
 
 SCREEN_WIDTH = 1352
 SCREEN_HEIGHT = 878
 
-scale = 1 * pow(10, -6)
+scale = 1 * pow(10, -8)
-unit_scale = -3
-time = 0
-time_scale = 1
 
-sensor = Sensor( 50 * pow(10, -6), 30 * pow(10, -6),  20 * pow(10, -6))
+sensor = Sensor((50*pow(10, -9)) / scale, (200 * pow(10,-9)) / scale, (300 * pow(10, -9)) / scale)
-
-particle = Particle(10 * pow(10, -8), 7 * pow(10, -6), 1, 1)
-
-graph = Graph(4, 10, 0, 10)
 
 pygame.init()
 pygame.display.set_caption("CytoSim")
@@ -40,41 +32,18 @@ while True:
         scale = scale / 1.1
       elif event.y == -1:
         scale = scale * 1.1
-    if event.type == pygame.KEYDOWN:
-      print("Button")
-      if event.key == pygame.K_UP:
-        scale = scale / 1.1
-      elif event.key == pygame.K_DOWN:
-        scale = scale * 1.1
-
 
   x, y = screen.get_size()
 
-  scale_bar_size = abs((x - (x * .1)) - (x - (x * .1)) - (1 * pow(10, unit_scale) / scale))
-
-  if int(scale_bar_size) < 40:
-    unit_scale += 1
-  elif int(scale_bar_size) > 500:
-    unit_scale -= 1
-
-  scale_bar_end_point = (x - (x * .1)) - (1 * pow(10, unit_scale) / scale)
-
   screen.fill((200,100,5))
 
-  sensor.display(x, y + (y / graph.ratio), screen, scale)
+  sensor.generate(x, y, screen)
-  particle.move(time_scale, scale, sensor.left_limit, sensor.right_limit, screen, y + (y / graph.ratio))
-  graph.draw(screen, x, y, time_scale)
 
-  volume = sensor.testSensor1(particle.distance, particle, scale, screen)
+  pygame.draw.circle(screen, (150,255,10), (x / 2, y /2), 3 * pow(10, -6) / scale)
-  print(volume)
 
-  graph.add_data(time, volume)
+  pygame.draw.line(screen, (255,255,255), (x - (x * .1), y - (y * .1)), ((x - (x * .1)) - (1 * pow(10, -6) / scale), y - (y * .1)))
-  # pygame.draw.circle(screen, (150,255,10), (x / 2, y /2), 3 * pow(10, -6) / scale)
 
-  pygame.draw.line(screen, (255,255,255), (x - (x * .1), y - (y * .1)), (scale_bar_end_point, y - (y * .1)))
+  print(scale)
-
+  #print((1 *pow(10, -6)) / scale)
-  # print((1 *pow(10, -6)) / scale)
-
-  time += time_scale 
 
   pygame.display.update()

particle.py

@@ -1,22 +1,16 @@
 import math
-import pygame
 
 class Particle:
   def __init__(self, speed, size, perm, rest):
     self.speed = speed
     self.size = size
-    self.radius = size / 2
     self.perm = perm
     self.rest = rest
-    self.volume = (4/3.0) * math.pi * pow(self.radius, 3) 
+    self.volume = (4/3.0) * math.pi * size * size * size 
-    self.distance = 0
 
-  def move(self, time_interval, scale, left_limit, right_limit, screen, height):
+  def move(self, time):
-    self.distance += (self.speed * time_interval) / scale
+    distance = self.speed * time
-    self.pixel_distance = self.distance + left_limit
+    return distance
-    if self.distance + left_limit + (self.size / (2 * scale)) > right_limit:
-      self.distance = 0
-    pygame.draw.circle(screen, (255,225,255), (left_limit + self.distance, height / 2), self.size / (2 * scale))
 
   def partialVol(self, height):
     partialVol = (1/3) * math.pi * height * height * ((3 * self.size) - height)

sensor.py

@@ -1,5 +1,4 @@
 import pygame
-import math
 
 class Sensor:
   def __init__(self, width, distance, space):
@@ -7,83 +6,50 @@ class Sensor:
     self.distance = distance
     self.space = space
     self.volume =  width * pow(distance, 2)
-    self.total_width = (4 * width) + space
-    self.total_height = 100 * pow(10, -6) - distance
     
-  def display(self, screenWidth, screenHeight, screen, scale):
+  def generate(self, screenWidth, screenHeight, screen):
-    center_x = screenWidth / 2
+    self.sensor1_x = (screenWidth / 2) - (self.space / 2) - self.width
-    center_y = screenHeight / 2
+    self.sensor1_y = 0
-    scaled_half_x = self.total_width / (2 * scale)
+    self.sensor1_x_size = self.width
-    scaled_half_y = self.total_height / (2 * scale)
+    self.sensor1_y_size = (screenHeight / 2) - (self.distance / 2)
-    scaled_width = self.width / scale
-    scaled_distance = self.distance / scale
-    scaled_space = self.space / scale
-    self.height = screenHeight
 
-    self.scaled_sensor1_left_limit = center_x - scaled_space - scaled_width 
+    self.inner1 = self.sensor1_x
-    self.scaled_sensor1_right_limit = center_x - scaled_space 
+    self.outer1 = self.inner1 + self.width
-    self.scaled_sensor2_left_limit = center_x + scaled_space 
-    self.scaled_sensor2_right_limit = center_x + scaled_space + scaled_width 
     
-    self.right_limit = center_x + scaled_half_x
+    sensor1a = pygame.Rect(self.sensor1_x, self.sensor1_y, self.sensor1_x_size, self.sensor1_y_size)
-    self.left_limit = center_x - scaled_half_x
+    sensor1b = pygame.Rect(self.sensor1_x, self.sensor1_y + self.sensor1_y_size + self.distance, self.sensor1_x_size, self.sensor1_y_size)
+    pygame.draw.rect(screen, (0, 0, 255), sensor1a)
+    pygame.draw.rect(screen, (0, 0, 255), sensor1b)
 
-    sensor1_rect_up = pygame.Rect(center_x - scaled_space - scaled_width, center_y - scaled_half_y, scaled_width, scaled_half_y - (scaled_distance / 2))
+    self.sensor2_x = (screenWidth / 2) + (self.space / 2)
-    sensor1_rect_down = pygame.Rect(center_x - scaled_space - scaled_width, center_y + (scaled_distance / 2), scaled_width, scaled_half_y - (scaled_distance / 2))
+    self.sensor2_y = 0
-    sensor2_rect_up = pygame.Rect(center_x + scaled_space, center_y - scaled_half_y, scaled_width, scaled_half_y - (scaled_distance / 2))
+    self.sensor2_x_size = self.width
-    sensor2_rect_down = pygame.Rect(center_x + scaled_space, center_y  + (scaled_distance / 2), scaled_width, scaled_half_y - (scaled_distance / 2))
+    self.sensor2_y_size = (screenHeight / 2) - (self.distance / 2)
 
-    pygame.draw.rect(screen, (0,200,0), sensor1_rect_up)
+    self.inner2 = self.sensor2_x
-    pygame.draw.rect(screen, (0,200,0), sensor1_rect_down)
+    self.outer2 = self.inner2 + self.width
-    pygame.draw.rect(screen, (0,200,0), sensor2_rect_up)
-    pygame.draw.rect(screen, (0,200,0), sensor2_rect_down)
-
-    pygame.draw.line(screen, (100,100,50), (center_x - scaled_half_x, center_y - (scaled_distance / 2)), (center_x + scaled_half_x, center_y - (scaled_distance / 2)))
-    pygame.draw.line(screen, (100,100,50), (center_x - scaled_half_x, center_y + (scaled_distance / 2)), (center_x + scaled_half_x, center_y + (scaled_distance / 2)))
-
-    pygame.draw.line(screen, (255,255,255), (center_x - scaled_half_x, center_y - scaled_half_y), (center_x + scaled_half_x, center_y - scaled_half_y), 7)
-    pygame.draw.line(screen, (255,255,255), (center_x + scaled_half_x, center_y - scaled_half_y), (center_x + scaled_half_x, center_y + scaled_half_y), 7)
-    pygame.draw.line(screen, (255,255,255), (center_x + scaled_half_x, center_y + scaled_half_y), (center_x - scaled_half_x, center_y + scaled_half_y), 7)
-    pygame.draw.line(screen, (255,255,255), (center_x - scaled_half_x, center_y + scaled_half_y), (center_x - scaled_half_x, center_y - scaled_half_y), 7)
     
+    sensor2a = pygame.Rect(self.sensor2_x, self.sensor2_y, self.sensor2_x_size, self.sensor2_y_size)
+    sensor2b = pygame.Rect(self.sensor2_x, self.sensor2_y + self.sensor2_y_size + self.distance, self.sensor2_x_size, self.sensor2_y_size)
+    pygame.draw.rect(screen, (0, 0, 255), sensor2a)
+    pygame.draw.rect(screen, (0, 0, 255), sensor2b)
 
+  def testSensor1(self, partCenter, particle):
+    if (particle.size >= abs(self.inner1 - (partCenter - particle.size))) and (particle.size >= abs(self.outer1 - (partCenter - particle.size))):
+      volume = ((particle.volume / 2) - (particle.partialVol(particle.size - ((partCenter - particle.size) - self.inner1)))) + ((particle.volume / 2) - particle.partialVol(particle.size - (self.outer1 - (partCenter - particle.size)))) 
+      return volume
+    elif particle.size >= abs(self.inner1 - (partCenter - particle.size)):
+      volume = particle.partialVol(particle.size - (self.inner1 - (partCenter - particle.size)))
+      return volume
+    elif particle.size >= abs(self.outer1 - (partCenter - particle.size)):
+      volume = particle.volume - particle.partialVol(particle.size - (self.outer1 - (partCenter - particle.size)))
+      return volume
+    elif ((partCenter - particle.size) >= self.inner1 and (partCenter - particle.size) <= self.outer1):
+      volume = particle.volume
+      return volume
+    else:
       return 0
 
-
-  def testSensor1(self, partCenter, particle, scale, screen):
-    particle_right_limit = particle.pixel_distance + (particle.radius / scale)
-    particle_left_limit = particle.pixel_distance - (particle.radius / scale)
-
-    pygame.draw.line(screen, (0,0,0), (particle_left_limit, self.height), (particle_left_limit, 0))
-    pygame.draw.line(screen, (0,100,0), (particle_right_limit, self.height), (particle_right_limit, 0))
-
-    pygame.draw.line(screen, (0,0,0), (self.scaled_sensor1_left_limit, self.height), (self.scaled_sensor1_left_limit, 0))
-    pygame.draw.line(screen, (0,100,0), (self.scaled_sensor1_right_limit, self.height), (self.scaled_sensor1_right_limit, 0))
-
-    if (particle_right_limit >= self.scaled_sensor1_left_limit and particle_left_limit < self.scaled_sensor1_left_limit):
-      if (particle.pixel_distance < self.scaled_sensor1_left_limit):
-        height = particle_right_limit - self.scaled_sensor1_left_limit
-        volume = ((math.pi * height * height) / 3) * ((3 * (particle.radius / scale)) - height)
-      else:
-        height = self.scaled_sensor1_left_limit - particle.pixel_distance
-        volume = ((math.pi * height * height) / 3) * ((3 * (particle.radius / scale)) - height)
-    elif (particle_right_limit <= self.scaled_sensor1_right_limit and particle_left_limit >= self.scaled_sensor1_left_limit):
-      volume = particle.volume / scale
-    elif (particle_right_limit > self.scaled_sensor1_right_limit and particle_left_limit > self.scaled_sensor1_left_limit and particle_left_limit < self.scaled_sensor1_right_limit):
-      if (particle.pixel_distance > self.scaled_sensor1_right_limit):
-        height = particle.pixel_distance - self.scaled_sensor1_right_limit
-        volume = ((math.pi * height * height) / 3) * ((3 * (particle.radius / scale)) - height)
-      else:
-        height = self.scaled_sensor1_right_limit - particle_left_limit
-        volume = ((math.pi * height * height) / 3) * ((3 * (particle.radius / scale)) - height)
-    else:
-      volume = 0
-
-
-    return volume * scale
-
-
-
   def testSensor2(self, partCenter, particle):
     if (particle.size >= abs(self.inner2 - (partCenter - particle.size))) and (particle.size >= abs(self.outer2 - (partCenter - particle.size))):
       volume = ((particle.volume / 2) - (particle.partialVol(particle.size - ((partCenter - particle.size) - self.inner2)))) + ((particle.volume / 2) - particle.partialVol(particle.size - (self.outer2 - (partCenter - particle.size))))