def __init__(self, network: NetworkModel):
ComputeShaderHandler().create("node_noise", "node/node_noise.comp")
object_size, render_data_offset, render_data_size = \
get_buffer_settings(network.num_classes, ADDITIONAL_NODE_BUFFER_DATA)
self.node_buffer: SwappingBufferObject = SwappingBufferObject(
ssbo=True,
object_size=object_size,
render_data_offset=render_data_offset,
render_data_size=render_data_size)
self.ssbo_handler: VertexDataHandler = VertexDataHandler([
(self.node_buffer, 0)
])
self.nodes: List[Node] = network.get_nodes()
self.point_count: int = 0
self.nearest_view_z: int = -1000000
self.farthest_view_z: int = 1000000
self.max_sample_points: int = 0
self.node_min_importance: float = network.node_min_importance
self.node_max_importance: float = network.node_max_importance
self.set_data()
def get(self, role):
devices = NetworkModel.fetch_db(role)
if devices:
try:
return {'devices': [device.json() for device in devices]}
except:
return devices.json()
return {'message': 'No data found'}, 404
def post(self, role, device):
if NetworkModel.fetch_db(role, device):
rule = ACL.parser.parse_args()
if RuleModel.get_rules(device, **rule):
return {'message':'Rule already exit for the device.'},400
RuleModel(device, **rule).save_to_db()
return {'message':'Rule successfully added.'}
return {'message':'{} device do not exist.'.format(device)},404
def get(self, role, device):
if role == 'switch':
return {'message':'This feature is not applicable for switches.'},400
elif NetworkModel.fetch_db(role, device):
rules = RuleModel.get_rules(device)
if rules:
return {'rules':[rule.json() for rule in rules]},201
return {'message':'No rule present for this device'},201
return {'message':'No such device present with name {}.'.format(device)},404
def __init__(self, layer_nodes: List[int],
processing_config: ProcessingConfig,
importance_data: ImportanceDataHandler = None,
processed_nn: ProcessedNNHandler = None):
logging.info("Prepare network processing for network of size: %s" % layer_nodes)
self.layer_nodes: List[int] = layer_nodes
self.layer_distance: float = processing_config["layer_distance"]
self.layer_width: float = processing_config["layer_width"]
logging.info("Create network model...")
self.network: NetworkModel = NetworkModel(self.layer_nodes, self.layer_width, self.layer_distance,
importance_data, processed_nn, processing_config["prune_percentage"])
self.sample_length: float = self.network.layer_width / processing_config["sampling_rate"]
self.grid_cell_size: float = self.sample_length / 3.0
self.sample_radius: float = self.sample_length * 2.0
RenderShaderHandler().set_classification_number(self.network.num_classes)
ComputeShaderHandler().set_classification_number(self.network.num_classes)
self.node_advection_status: AdvectionProgress = AdvectionProgress(self.network.average_node_distance,
processing_config["node_bandwidth_reduction"],
self.grid_cell_size * 2.0)
self.edge_advection_status: AdvectionProgress = AdvectionProgress(self.network.average_edge_distance,
processing_config["edge_bandwidth_reduction"],
self.grid_cell_size * 2.0)
self.edge_importance_type: int = processing_config["edge_importance_type"]
logging.info("Create grid...")
self.grid: Grid = Grid(Vector3([self.grid_cell_size, self.grid_cell_size, self.grid_cell_size]),
self.network.bounding_volume, self.layer_distance)
logging.info("Prepare node processing...")
self.node_processor: NodeProcessor = NodeProcessor(self.network)
self.node_renderer: NodeRenderer = NodeRenderer(self.node_processor, self.grid)
logging.info("Prepare edge processing...")
self.edge_processor: EdgeProcessor = EdgeProcessor(self.sample_length,
edge_importance_type=self.edge_importance_type)
self.edge_processor.set_data(self.network)
if not self.edge_processor.sampled:
self.edge_processor.init_sample_edge()
self.edge_renderer: EdgeRenderer = EdgeRenderer(self.edge_processor, self.grid)
logging.info("Prepare grid processing...")
self.grid_processor: GridProcessor = GridProcessor(self.grid, self.node_processor, self.edge_processor, 10000.0)
self.grid_processor.calculate_position()
self.grid_renderer: GridRenderer = GridRenderer(self.grid_processor)
self.action_finished: bool = False
self.last_action_mode: NetworkProcess = NetworkProcess.RESET
self.edge_smoothing: bool = processing_config["smoothing"]
self.edge_smoothing_iterations: int = processing_config["smoothing_iterations"]
self.bar: ProgressBar or None = None
def delete(self, role, device):
if role == 'switch':
return {'message':'No rule(s) exist for switch.'},400
elif NetworkModel.fetch_db(role, device):
del_rule = ACL.parser.parse_args()
rules = RuleModel.get_rules(device, **del_rule)
if rules:
for rule in rules:
rule.delete_from_db()
return {'message':'Rule is deleted.'},201
else:
return {'message':'No rule exist. Please check inputs.'},400
def delete(self, role):
data = Network.parser.parse_args()
device = NetworkModel.fetch_db(role, data['device_name'])
if device:
device.delete_from_db()
return {
'message': 'Device {} is removed.'.format(data['device_name'])
}
return {
'message':
'Device {} is not found in {}.'.format(data['device_name'], role)
}, 404
def put(self, role):
data = Network.parser.parse_args()
device = NetworkModel.fetch_db(role, data['device_name'])
if device:
device.status = data['status']
device.save_to_db()
return device.json()
else:
return {
'message':
'No device with name {} found in {}.'.format(
data['device_name'], role)
}, 404
def set_data(self, network: NetworkModel):
edges: List[List[List[Edge]]] = network.generate_filtered_edges(self.max_edges_per_buffer)
self.edge_min_importance = network.edge_min_importance
self.edge_max_importance = network.edge_max_importance
self.layer_edge_count = [len(layer) for layer in edges]
self.layer_container_edge_count = [[len(container) for container in layer] for layer in edges]
self.edge_count = sum([sum(layer) for layer in self.layer_container_edge_count])
# calculate smoothing radius
max_distance: float = network.generate_max_distance()
self.smooth_radius = (int((max_distance * 2.0) / self.sample_length) * 8.0) / 100.0
# read or calculate max sample point value for buffer objects
if len(edges[0][0][0].sample_data) > 8:
self.sampled = True
self.max_sample_points = int(len(edges[0][0][0].sample_data) / 4)
else:
self.max_sample_points = int((max_distance * 5.0) / self.sample_length) + 2
if len(self.sample_buffer) > 0:
self.delete()
self.fill_buffer(edges, network.num_classes)
def post(self, role):
data = Network.parser.parse_args()
if NetworkModel.fetch_db(role, data['device_name']):
return {
'message':
'The device {} is already exist in {}.'.format(
data['device_name'], role)
}, 400
if data['status']:
device = NetworkModel(data['device_name'], role, data['status'])
else:
device = NetworkModel(data['device_name'], role, "not found")
try:
device.save_to_db()
except:
return {
'message':
'Could not add device {} in {}. Kindly recheck inputs.'.format(
data['device_name'], role)
}, 500
return device.json()