OpenCDA Python API Reference¶
This reference contains all the details of the OpenCDA Python API.
OpenCDA Module: co_simulation¶
Co-simulation with SUMO, will be released in v0.2.
OpenCDA Module: core¶
This is the core module of the OpenCDA framework that regulates the motion relatetd controls.
opencda.core.actuation¶
This is the actuation function stack that controls CARLA ego vehicle.
opencda.core.actuation.control_manager¶
Controller interface.
Classes
ControlManager(control_config)
: Interface to select different types of controller.
Construct class
Args:
control_config(dict): Controller params.
### Methods
`run_step(self, target_speed, waypoint)`
:
`update_info(self, ego_pos, ego_speed)`
:
opencda.core.actuation.pid_controller¶
PID Control Class.
Classes
Controller(args)
: VehiclePIDController is the combination of two PID controllers
(lateral and longitudinal) to perform the
low level control a vehicle from client side
Construct class
:param args: the parameters for pid controller
### Methods
`dynamic_pid(self)`
: Compute kp, kd, ki based on current speed
:return:
`lat_run_step(self, target_location)`
: Generate the throttle command based on current speed and target speed
:param target_location: target waypoint
:return: steering scalar
`lon_run_step(self, target_speed)`
: Generate the throttle command based on current speed and target speed
:param target_speed: target speed in km/h
:return: throttle scalar
`run_step(self, target_speed, waypoint)`
: Execute one step of control invoking both lateral and longitudinal
PID controllers to reach a target waypoint
at a given target_speed.
:param target_speed: desired vehicle speed
:param waypoint: target location encoded as a waypoint
:return: control command
`update_info(self, ego_pos, ego_spd)`
: Update ego position and speed to controller.
:param ego_pos: ego position, carla.transform
:param ego_spd: ego speed, km/h
:return:
opencda.core.application¶
V2V, V2I application are all managed with this class.
opencda.core.application - Platooning¶
Here, we provide an implementation of Autonomous vehicle platooning based on finite state machine.
opencda.core.application.platooning.fsm¶
Finite State Machine
Classes
FSM(value, names=None, *, module=None, qualname=None, type=None, start=1)
: An enumeration.
### Ancestors (in MRO)
* enum.Enum
### Class variables
`ABONDON`
:
`BACK_JOINING`
:
`CUT_IN_TO_BACK`
:
`DISABLE`
:
`FRONT_JOINING`
:
`JOINING`
:
`JOINING_FINISHED`
:
`LEADING_MODE`
:
`MAINTINING`
:
`MOVE_TO_POINT`
:
`OPEN_GAP`
:
`SEARCHING`
:
opencda.core.application.platooning.platoon_behavior_agent¶
Behavior manager for platooning specifically
Classes
PlatooningBehaviorAgent(vehicle, vehicle_manager, v2x_manager, behavior_yaml, platoon_yaml, carla_map)
: The behavior agent for platooning
Construct class
:param vehicle: carla actor todo:remove this later
:param vehicle_manager: vehicle manager of this agent.
:param v2x_manager: communication manager
:param behavior_yaml: configure yaml file for normal behavior agent
:param platoon_yaml: configure yaml file for platoon behavior agent
:param carla_map: Carla HD Map
:return
### Ancestors (in MRO)
* opencda.core.plan.behavior_agent.BehaviorAgent
### Methods
`calculate_gap(self, distance)`
: Calculate the current vehicle and frontal vehicle's time/distance gap
:param distance: distance between the ego vehicle and frontal vehicle
:return:
`joining_finish_manager(self, insert_vehicle='front')`
: Called when a joining is finish to update the platoon manager list.
:param insert_vehicle: indicate use the front or rear vehicle index to update the platoon manager list.
:return:
`platooning_following_manager(self, inter_gap)`
: Car following behavior in platooning with gap regulation
:param inter_gap: the gap designed for platooning
:return:
`platooning_merge_management(self, frontal_vehicle_vm)`
: Merge the vehicle into the platooning
:param frontal_vehicle_vm:
:return:
`run_step(self, target_speed=None, collision_detector_enabled=True, lane_change_allowed=True)`
: Run a single step for navigation under platooning agent. Finite state machine is used to switch between
different platooning states.
Args:
target_speed (float): Target speed in km/h
collision_detector_enabled (bool): Whether collision detection enabled.
lane_change_allowed (bool): Whether lane change is allowed.
Returns:
`run_step_back_joining(self)`
: Back-joining Algorithm
:return: control command and whether back joining finished
opencda.core.application.platooning.platoon_debug_helper¶
Analysis + visualization functions for platooning.
Classes
PlatoonDebugHelper(actor_id)
: This class aims to save statistics for platoon behaviour
Attributes:
time_gap_list (list): The list containing intra-time-gap(s) of all time-steps
dist_gap_list(list): The list containing distance gap(s) of all time-steps
### Ancestors (in MRO)
* opencda.core.plan.planer_debug_helper.PlanDebugHelper
opencda.core.application.platooning.platooning_manager¶
Platooning Manager.
Classes
PlatooningManager(config_yaml, cav_world)
: Platooning manager for vehicle managers
Construct class
:param config_yaml:
:param cav_world: CAV world object
### Methods
`add_member(self, vehicle_manager, leader=False)`
: Add memeber to the current platooning
:param leader: whether this cav is a leader
:param vehicle_manager:
:return:
`cal_center_loc(self)`
: Calculate center location of the platoon
:return:
`destroy(self)`
: Destroy vehicles
:return:
`evaluate(self)`
:
`reset_speed(self)`
: After joining request accepted for certain steps, the platoon will return to the origin speed.
:return:
`response_joining_request(self, request_loc)`
: Identify whether to accept the joining request based on capacity.
Args:
request_loc (carla.Location): request vehicle location.
Returns:
`run_step(self)`
: Run a step for each vehicles.
:return:
`set_destination(self, destination)`
: Set desination of the vehicle managers in the platoon.
TODO: Currently we assume all vehicles in a platoon will have the same destination
:return:
`set_lead(self, vehicle_manager)`
: Set the leader of the platooning
:param vehicle_manager:
:return:
`set_member(self, vehicle_manager, index, lead=False)`
: Set member at specific index
:param lead:
:param vehicle_manager:
:param index:
:return:
`update_information(self)`
: Update CAV world information for every member in the list.
:return:
`update_member_order(self)`
: Update the members' front and rear vehicle.
This should be called whenever new member added to the platoon list
:return:
opencda.core.application.platooning.platooning_plugin¶
Platooning plugin for communication and track FSM.
Classes
PlatooningPlugin(search_range, cda_enabled)
: Platooning Plugin
Construct class
:param search_range:
:param cda_enabled:
### Methods
`match_platoon(self, cav_world)`
: A naive way to find the best position to join a platoon
:param cav_world: an object containing all existing platoons
:return: platoon found or not, closest platoon member team id, and a list containing the vehicle managers
`reset(self)`
: Reset to the origin status
:return:
`search_platoon(self, ego_pos, cav_world)`
: Search platoon candidate in the range
:param ego_pos:
:param cav_world:
:return: the uuid of platoon member, platoon object
`set_platoon(self, in_id, platooning_object=None, platooning_id=None, leader=False)`
: Set platooning status
:param platooning_object: platooning manager todo: remove this later
:param platooning_id: platoon id the cav belongs to
:param in_id: the position in the platoon, etc. 0 represents leader and 1 represents the second position
:param leader: indicate whether this cav is a leader in platoon
:return:
`set_status(self, status)`
: Set FSM status
:param status:
:return:
`update_info(self, ego_pos, ego_spd)`
: Update the ego position and speed
:param ego_pos: ego position, carla.Transform
:param ego_spd: ego speed, km/h
:return:
opencda.core.common¶
This module regulates simulation related objects in the CARLA simulation world.
opencda.core.common.cav_world¶
Class that regulates the CARLA simulation world.
Classes
CavWorld(apply_ml=False)
: A customized world object to save all CDA vehicle information and shared ML models
:return:
Construct class.
Args:
apply_ml (bool): whether apply ml/dl models in this simulation, please make sure
you have install torch/sklearn before setting this to True.
### Methods
`get_platoon_dict(self)`
: Return existing platoons
:return:
`get_vehicle_managers(self)`
: Return vehicle manager dictionary
:return:
`locate_vehicle_manager(self, loc)`
: Locate the vehicle manager based on the given location.
Args:
loc (carla.Location): vehicle location.
Returns:
(VehicleManager): The vehicle manager at the give location.
`update_platooning(self, platooning_manger)`
: Add created platooning
:param platooning_manger:
:return:
`update_vehicle_manager(self, vehicle_manager)`
: Update created CAV manager to the world
:param vehicle_manager:
:return:
opencda.core.common.misc¶
Module with auxiliary functions.
Functions
cal_distance_angle(target_location, current_location, orientation)
: Calculate the vehicle current relative distance to target location
:param target_location:
:param current_location:
:param orientation:
:return: distance and angle
compute_distance(location_1, location_2)
: Euclidean distance between 3D points
:param location_1: 3D points
:param location_2: 3D points
compute_magnitude_angle(target_location, current_location, orientation)
: Compute relative angle and distance between a target_location and a current_location
:param target_location: location of the target object
:param current_location: location of the reference object
:param orientation: orientation of the reference object
:return: a tuple composed by the distance to the object and the angle between both objects
distance_vehicle(waypoint, vehicle_transform)
: Returns the 2D distance from a waypoint to a vehicle
:param waypoint: actual waypoint
:param vehicle_transform: transform of the target vehicle
draw_trajetory_points(world, waypoints, z=0.25, color=<carla.libcarla.Color object>, lt=5, size=0.1)
: Draw a list of trajetory points
:param size:
:param lt:
:param color:
:param world:
:param waypoints:
:param z:
:return:
draw_waypoints(world, waypoints, z=0.5)
: Draw a list of waypoints at a certain height given in z.
:param world: carla.world object
:param waypoints: list or iterable container with the waypoints to draw
:param z: height in meters
get_acc(vehicle, meters=False)
: Compute speed of a vehicle in Km/h.
:param meters: use m/s or km/h
:param vehicle: the vehicle for which speed is calculated
:return: speed as a float in Km/h
get_speed(vehicle, meters=False)
: Compute speed of a vehicle in Km/h.
:param meters: use m/s or km/h
:param vehicle: the vehicle for which speed is calculated
:return: speed as a float in Km/h
is_within_distance(target_location, current_location, orientation, max_distance, d_angle_th_up, d_angle_th_low=0)
: Check if a target object is within a certain distance from a reference object.
A vehicle in front would be something around 0 deg, while one behind around 180 deg.
:param target_location: location of the target object
:param current_location: location of the reference object
:param orientation: orientation of the reference object
:param max_distance: maximum allowed distance
:param d_angle_th_up: upper thereshold for angle
:param d_angle_th_low: low thereshold for angle (optional, default is 0)
:return: True if target object is within max_distance ahead of the reference object
is_within_distance_ahead(target_transform, current_transform, max_distance)
: Check if a target object is within a certain distance in front of a reference object.
:param target_transform: location of the target object
:param current_transform: location of the reference object
:param orientation: orientation of the reference object
:param max_distance: maximum allowed distance
:return: True if target object is within max_distance ahead of the reference object
positive(num)
: Return the given number if positive, else 0
:param num: value to check
vector(location_1, location_2)
: Returns the unit vector from location_1 to location_2
:param location_1, location_2: carla.Location objects
opencda.core.common.v2x_manager¶
Communication manager for cooperation.
Classes
V2XManager(cav_world, config_yaml)
: V2X Manager for platooning, cooperative perception and so on
Construct class
:param config_yaml: configuration yaml file
### Methods
`add_platoon_blacklist(self, pmid)`
: Add an existing platoon to current blacklist
:param pmid: platoon id
:return:
`get_platoon_front_rear(self)`
: Get the ego vehicle's front and rear cav in the platoon
:return:
`get_platoon_manager(self)`
: Retrieve the platoon manager the cav belongs to and the corresponding id
:return:
`get_platoon_status(self)`
: Retrive the FSM status for platooning application
:return:
`in_platoon(self)`
: Check whether the vehicle is inside the platoon
:return: bool, flag indication whether in a platoon
`match_platoon(self)`
: A naive way to find the best position to join a platoon
:return:
`set_platoon(self, in_id, platooning_object=None, platooning_id=None, leader=False)`
: Set platooning status
:param platooning_object: platooning world that contains all platoon information todo: remove this later
:param platooning_id: platoon id the cav belongs to
:param in_id: the position in the platoon, etc. 0 represents leader and 1 represents the second position
:param leader: indicate whether this cav is a leader in platoon
:return:
`set_platoon_front(self, vm)`
: Set the frontal vehicle to another vehicle
:param vm: vehicle manager
:return:
`set_platoon_rear(self, vm)`
: Set the rear vehicle to another vehicle
:param vm:
:return:
`set_platoon_status(self, status)`
: Set the cav to a different fsm status
:param status: fsm status
:return:
`update_info(self, ego_pos, ego_spd)`
: Update all communication plugins with current localization info
opencda.core.common.vehicle_manager¶
Basic class of CAV.
Classes
VehicleManager(vehicle, config_yaml, application, carla_map, cav_world)
: A class manager to embed different modules with vehicle together
Construction class
:param vehicle: carla actor
:param config_yaml: a dictionary that contains the parameters of the vehicle
:param application: application category, support:['single','platoon'] currently
:param carla_map: Carla HD Map
:param cav_world: CAV world object
### Methods
`destroy(self)`
: Destroy the actor vehicle
:return:
`run_step(self, target_speed=None)`
: Execute one step of navigation.
:return:
`set_destination(self, start_location, end_location, clean=False, end_reset=True)`
: Wrapper function to set global route
:param start_location:
:param end_location:
:param clean:
:param end_reset:
:return:
`update_info(self)`
: Call perception and localization module to retrieve surrounding info an ego position.
:return:
opencda.core.plan¶
The main planing module for OpenCDA.
opencda.core.plan.behavior_agent¶
This module implements an agent that roams around a track following random waypoints and avoiding other vehicles. The agent also responds to traffic lights, traffic signs, and has different possible configurations.
Classes
BehaviorAgent(vehicle, carla_map, config_yaml)
: A modulized version of BehaviorAgent
Construct class
:param vehicle: carla actor
:param config_yaml: a dictionary containing all initialization params
provide customized function under customize/controller
### Descendants
* opencda.core.application.platooning.platoon_behavior_agent.PlatooningBehaviorAgent
### Methods
`add_white_list(self, vm)`
: Add vehicle manager to
Args:
vm ():
Returns:
`car_following_manager(self, vehicle, distance, target_speed=None)`
: Module in charge of car-following behaviors when there's
someone in front of us.
:param target_speed:
:param vehicle: car to follow
:param distance: distance from vehicle
:return control: carla.VehicleControl
`collision_manager(self, rx, ry, ryaw, waypoint, adjacent_check=False)`
: This module is in charge of warning in case of a collision
:param adjacent_check: whether it is a check for adjacent lane
:param rx: x coordinates of plan path
:param ry: y coordinates of plan path
:param ryaw: yaw angle
:param waypoint: current waypoint of the agent
:return vehicle_state: True if there is a vehicle nearby, False if not
:return vehicle: nearby vehicle
:return distance: distance to nearby vehicle
`get_local_planner(self)`
: return the local planner
`lane_change_management(self)`
: Identify whether a potential hazard exits if operating lane change.
Returns:
bool: whether the lane change is dangerous
`overtake_management(self, obstacle_vehicle)`
: Overtake behavior.
:param obstacle_vehicle: the vehicle
:return:
`reroute(self, spawn_points)`
: This method implements re-routing for vehicles approaching its destination.
It finds a new target and computes another path to reach it.
:param spawn_points: list of possible destinations for the agent
`run_step(self, target_speed=None, collision_detector_enabled=True, lane_change_allowed=True)`
: Execute one step of navigation
:param collision_detector_enabled: whether to enable collision detection.
:param target_speed: a manual order to achieve certain speed.
:param lane_change_allowed: whether lane change is allowed. This is passed from platoon behavior agent.
:return: control: carla.VehicleControl
`set_destination(self, start_location, end_location, clean=False, end_reset=True, clean_history=False)`
: This method creates a list of waypoints from agent's position to destination location
based on the route returned by the global router.
:param end_reset: indicates whether the new destination is a temporary destination
:param start_location: initial position
:param end_location: final position
:param clean: boolean to clean the waypoint queue
:param clean_history:
`traffic_light_manager(self, waypoint)`
: This method is in charge of behaviors for red lights and stops.
WARNING: What follows is a proxy to avoid having a car brake after running a yellow light.
This happens because the car is still under the influence of the semaphore,
even after passing it. So, the semaphore id is temporarely saved to
ignore it and go around this issue, until the car is near a new one.
:param waypoint: current waypoint of the agent
`update_information(self, ego_pos, ego_speed, objects)`
: Update the perception and localization information to the behavior agent.
Args:
ego_pos (carla.Transform): ego position from localization module.
ego_speed (float): km/h, ego speed.
objects (dictionary): Objects detection results from perception module.
`white_list_match(self, obstacles)`
: Match the detected obstacles with the white list. Remove the obstacles that are in white list.
The white list contains all position of target platoon member for joining.
Args:
obstacles (list): a list of carla.Vehicle or ObstacleVehicle
Returns:
(list): the new list of obstacles.
opencda.core.plan.collision_check¶
This module is used to check collision possibility.
Classes
CollisionChecker(time_ahead=1.2, circle_radius=1.3, circle_offsets=None)
: Construction method
:param time_ahead: how many seconds we look ahead in advance for collision check
:param circle_offsets: the offset between collision checking circle and the trajectory point
:param circle_radius: The radius of the collision checking circle
### Methods
`adjacent_lane_collision_check(self, ego_loc, target_wpt, overtake, world)`
: Generate a straight line in the adjacent lane for collision detection during
overtake/lane change. Todo: current version may not work well on curved lane
Args:
ego_loc (carla.Location): Ego Location.
target_wpt (carla.Waypoint): the check point in the adjacent at a far distance.
overtake (bool): indicate whether this is an overtake or normal lane change behavior.
world (carla.World): CARLA Simulation world, used to draw debug lines.
Returns:
list: the x coordinates of the collision check line in the adjacent lane
list: the y coordinates of the collision check line in the adjacent lane
list: the yaw angle of the the collision check line in the adjacent lane
`collision_circle_check(self, path_x, path_y, path_yaw, obstacle_vehicle, speed, adjacent_check=False)`
: Use circled collision check to see whether potential hazard on the forwarding path
:param adjacent_check: always give full path for adjacent lane check
:param speed: ego vehicle speed in m/s
:param path_yaw: a list of yaw angles
:param path_x: a list of x coordinates
:param path_y: a loist of y coordinates
:param obstacle_vehicle: potention hazard vehicle on the way
:return:
`is_in_range(self, ego_pos, target_vehicle, candidate_vehicle, carla_map)`
: Check whether there is a obstacle vehicle between target_vehicle and ego_vehicle during back_joining
:param carla_map: carla map
:param ego_pos: Ego vehicle position
:param target_vehicle: The vehicle that is suppose to be catched
:param candidate_vehicle: The possible obstacle vehicle blocking the ego vehicle and target vehicle
:return:
opencda.core.plan.drive_profile_plotting¶
Tools to plot velocity, acceleration, curvation.
Functions
draw_acceleration_profile_single_plot(acceleration)
: Draw velocity profiles in a single plot
:param acceleration:
:return:
draw_dist_gap_profile_singel_plot(gap_list)
: Draw distance gap profiles in a single plot
:param gap_list: time gap
:return:
draw_sub_plot(velocity_list, acceleration_list, time_gap_list, distance_gap_list)
: This is a specific function that draws 4 in 1 images for trajectory following task
:param velocity_list:
:param distance_gap_list:
:param time_gap_list:
:param acceleration_list:
:return:
draw_time_gap_profile_singel_plot(gap_list)
: Draw inter gap profiles in a single plot
:param gap_list: time gap
:return:
draw_ttc_profile_single_plot(ttc_list)
: Draw ttc.
:param ttc_list: ttc
:return:
draw_velocity_profile_single_plot(velocity_list)
: Draw velocity profiles in a single plot
:param velocity_list:
:return:
dump_data(data)
: Dump data to json file
:param data: dictionary containing all stats
:return:
opencda.core.plan.global_route_planner¶
This module provides GlobalRoutePlanner implementation.
Classes
GlobalRoutePlanner(dao)
: This class provides a very high level route plan.
Instantiate the class by passing a reference to
A GlobalRoutePlannerDAO object.
Constructor
### Methods
`abstract_route_plan(self, origin, destination)`
: The following function generates the route plan based on
origin : carla.Location object of the route's start position
destination : carla.Location object of the route's end position
return : list of turn by turn navigation decisions as
agents.navigation.local_planner.RoadOption elements
Possible values are STRAIGHT, LEFT, RIGHT, LANEFOLLOW, VOID
CHANGELANELEFT, CHANGELANERIGHT
`setup(self)`
: Performs initial server data lookup for detailed topology
and builds graph representation of the world map.
`trace_route(self, origin, destination)`
: This method returns list of (carla.Waypoint, RoadOption)
from origin to destination
opencda.core.plan.global_route_planner_dao¶
This module provides implementation for GlobalRoutePlannerDAO.
Classes
GlobalRoutePlannerDAO(wmap, sampling_resolution)
: This class is the data access layer for fetching data
from the carla server instance for GlobalRoutePlanner
Constructor method.
:param wmap: carla.world object
:param sampling_resolution: sampling distance between waypoints
### Methods
`get_resolution(self)`
: Accessor for self._sampling_resolution
`get_topology(self)`
: Accessor for topology.
This function retrieves topology from the server as a list of
road segments as pairs of waypoint objects, and processes the
topology into a list of dictionary objects.
:return topology: list of dictionary objects with the following attributes
entry - waypoint of entry point of road segment
entryxyz- (x,y,z) of entry point of road segment
exit - waypoint of exit point of road segment
exitxyz - (x,y,z) of exit point of road segment
path - list of waypoints separated by 1m from entry
to exit
`get_waypoint(self, location)`
: The method returns waypoint at given location
:param location: vehicle location
:return waypoint: generated waypoint close to location
opencda.core.plan.local_planner_behavior¶
This module contains a local planner to perform low-level waypoint following based on PID controllers.
Classes
LocalPlanner(agent, carla_map, config_yaml)
: LocalPlanner implements the basic behavior of following a trajectory
of waypoints that is generated on-the-fly.
The low-level motion of the vehicle is computed by using two PID controllers,
one is used for the lateral control
and the other for the longitudinal control (cruise speed).
When multiple paths are available (intersections)
this local planner makes a random choice.
:param agent: agent that regulates the vehicle
:param config_yaml: local planner configuration file
### Methods
`generate_path(self)`
: Generate the smooth path using cubic spline
:return: rx, ry, ryaw, rk: list of planned path points' x,y coordinates, yaw angle and curvature
`generate_trajectory(self, rx, ry, rk)`
: Sampling the generated path and assign speed to each point
:param rx: x coordinates of planning path
:param ry: y coordinates of planning path
:param rk: curvature of planning path
:param debug: whether to draw the whole plan path
:return:
`get_trajetory(self)`
: Get the trajetory
:return:
`pop_buffer(self, vehicle_transform)`
: Remove waypoints achieved
:return:
`run_step(self, rx, ry, rk, target_speed=None, trajectory=None, following=False)`
: Execute one step of local planning which involves
running the longitudinal and lateral PID controllers to
follow the smooth waypoints trajectory.
:param rx: generated path x coordinates
:param ry: generated path y coordinates
:param rk: generated path curvatures
:param following: whether the vehicle is under following status
:param trajectory: pre-generated trajectory only for following vehicles in the platooning
:param target_speed: desired speed
:return: next trajectory point's target speed and waypoint
`set_global_plan(self, current_plan, clean=False)`
: Sets new global plan.
:param clean:
:param current_plan: list of waypoints in the actual plan
`update_information(self, ego_pos, ego_speed)`
: Update the ego position and speed for trajectory planner.
Args:
ego_pos (carla.Transform): Ego position from localization module.
ego_speed (float): Ego speed(km/h) from localization module.
Returns:
RoadOption(value, names=None, *, module=None, qualname=None, type=None, start=1)
: RoadOption represents the possible topological configurations
when moving from a segment of lane to other.
### Ancestors (in MRO)
* enum.Enum
### Class variables
`CHANGELANELEFT`
:
`CHANGELANERIGHT`
:
`LANEFOLLOW`
:
`LEFT`
:
`RIGHT`
:
`STRAIGHT`
:
`VOID`
:
opencda.core.plan.planer_debug_helper¶
Analysis + Visualization functions for planning.
Classes
PlanDebugHelper(actor_id)
: This class aims to save statistics for planner behaviour
Attributes:
speed_list (list): The list containing speed info(m/s) of all time-steps
acc_list(list): The list containing acceleration info(m^2/s) of all time-steps
ttc_list(list): The list containing ttc info(s) for all time-steps
count(int): Used to count how many simulation steps have been executed.
### Descendants
* opencda.core.application.platooning.platoon_debug_helper.PlatoonDebugHelper
### Methods
`evaluate(self)`
:
`update(self, ego_speed, ttc)`
: Update the speed info.
Args:
ego_speed(km/h): Ego speed.
ttc(s): time to collision.
Returns:
opencda.core.plan.spline¶
Cubic spline planner.
Functions
calc_spline_course(x, y, ds=0.1)
: Calculate the spline based on x,y location and delta time ds.
Classes
Spline(x, y)
: Cubic Spline class
### Methods
`calc(self, t)`
: Calc position
if t is outside of the input x, return None
`calcd(self, t)`
: Calc first derivative
if t is outside of the input x, return None
`calcdd(self, t)`
: Calc second derivative
Spline2D(x, y)
: 2D Cubic Spline class
### Methods
`calc_curvature(self, s)`
: calc curvature
`calc_position(self, s)`
: calc position
`calc_yaw(self, s)`
: calc yaw
opencda.core.sensing¶
This is the sensing stack module of the OpenCDA.
opencda.core.sensing.localization.¶
The localization functions are implemented in this class.
opencda.core.senesing.localization.coordinate_transform¶
Functions to transfer coordinates under different coordinate system.
Functions
geo_to_transform(lat, lon, alt, lat_0, lon_0, alt_0)
: Convert WG84 to ENU. The origin of the ENU should pass the geo reference.
Note this function is a writen by reversing the official API transform_to_geo.
:param lat: current latitude
:param lon: current longitude
:param alt: current altitude
:param lat_0: geo_ref latitude
:param lon_0: geo_ref longitude
:param alt_0: geo_ref altitude
:return:
opencda.core.sensing.localization.extented_kalman_filter¶
Use Extended Kalman Filter on GPS + IMU for better localization.
Classes
ExtentedKalmanFilter(dt)
: Kalman Filter implementation for gps + imu
Construct class
Args:
dt(float): unit time step for simulation.
### Methods
`jacob_f(self, x, u)`
: Jacobian of Motion Model motion model
x_{t+1} = x_t+v*dt*cos(yaw)
y_{t+1} = y_t+v*dt*sin(yaw)
yaw_{t+1} = yaw_t+omega*dt
v_{t+1} = v{t}
so
dx/dyaw = -v*dt*sin(yaw)
dx/dv = dt*cos(yaw)
dy/dyaw = v*dt*cos(yaw)
dy/dv = dt*sin(yaw)
`motion_model(self, x, u)`
: Predict current position and yaw based on previous result.
X = F * X_prev + B * u
Args:
x (np.array): [x_prev, y_prev, yaw_prev, v_prev], shape: (4, 1).
u (np.array): [v_current, imu_yaw_rate], shape:(2, 1).
Returns:
np.array: predicted state.
`observation_model(self, x)`
: Project the state matrix to sensor measurement matrix.
Args:
x (np.array): [x, y, yaw, v], shape: (4. 1).
Returns:
np.array: predicted measurement.
`run_step(self, x, y, heading, velocity, yaw_rate_imu)`
: Apply EKF on current measurement and previous prediction
:param x: x(esu) coordinate from gnss sensor at current timestamp
:param y: y(esu) coordinate from gnss sensor at current timestamp
:param heading: heading direction at current timestamp
:param velocity: current speed
:param yaw_rate_imu: yaw rate rad/s from IMU sensor
:return: corrected x, y, heading, velocity
`run_step_init(self, x, y, heading, velocity)`
: Initalization for states
:param x:
:param y:
:param heading:
:param velocity:
:return:
opencda.core.sensing.localization.kalman_filter¶
Use Kalman Filter on GPS + IMU for better localization. Reference: https://www.bzarg.com/p/how-a-kalman-filter-works-in-pictures/
Classes
KalmanFilter(dt)
: Kalman Filter implementation for gps + imu
Construct class
Args:
dt(float): unit time step for simulation.
### Methods
`motion_model(self, x, u)`
: Predict current position and yaw based on previous result.
X = F * X_prev + B * u
Args:
x (np.array): [x_prev, y_prev, yaw_prev, v_prev], shape: (4, 1).
u (np.array): [v_current, imu_yaw_rate], shape:(2, 1).
Returns:
np.array: predicted state.
`observation_model(self, x)`
: Project the state matrix to sensor measurement matrix.
Args:
x (np.array): [x, y, yaw, v], shape: (4. 1).
Returns:
np.array: predicted measurement.
`run_step(self, x, y, heading, velocity, yaw_rate_imu)`
: Apply KF on current measurement and previous prediction
:param x: x(esu) coordinate from gnss sensor at current timestamp
:param y: y(esu) coordinate from gnss sensor at current timestamp
:param heading: heading direction at current timestamp
:param velocity: current speed
:param yaw_rate_imu: yaw rate rad/s from IMU sensor
:return: corrected x, y, heading
`run_step_init(self, x, y, heading, velocity)`
: Initial state filling.
Args:
x ():
y ():
heading ():
velocity ():
Returns:
opencda.core.sensing.localization.localization_debug_helper¶
Visualization tools for localization results.
Classes
LocDebugHelper(config_yaml, actor_id)
: This class aims to help users debugging their localization algorithms.
Users can apply this class to draw the x, y coordinate trajectory, yaw angle
and vehicle speed from GNSS raw measurements, Kalman filter(or any other filter),
and the groundtruth measurements. Error plotting is also enabled.
Attributes:
show_animation (bool):
x_scale(float):
y_scale(float):
Args:
config_yaml (dict):
actor_id(int):
### Methods
`evaluate(self)`
: Plot the localization related data points.
Args:
Returns:
`run_step(self, gnss_x, gnss_y, gnss_yaw, gnss_spd, filter_x, filter_y, filter_yaw, filter_spd, gt_x, gt_y, gt_yaw, gt_spd)`
: Run a single step for DebugHelper to save and animate(optional) the localization data.
Args:
gnss_x (float):
gnss_y (float):
gnss_yaw (float):
gnss_spd (float):
filter_x (float):
filter_y (float):
filter_yaw (float):
filter_spd (float):
gt_x (float):
gt_y (float):
gt_yaw (float):
gt_spd ()float:
Returns:
opencda.core.sensing.localization.localization_manager¶
Manager class for localization module.
Classes
GnssSensor(vehicle, config)
: Class for gnss sensors
Construct class
:param vehicle: carla actor
:param config: gnss configuration
ImuSensor(vehicle)
: IMU Sensor
Construct class
:param vehicle: Carla Actor
LocalizationManager(vehicle, config_yaml, carla_map)
: The core class that manages localization estimation.
Construction class
:param vehicle: carla actor
:param config_yaml: configuration related to localization
### Methods
`add_heading_direction_noise(self, heading_direction)`
: Add synthetic noise to heading direction.
:param heading_direction: groundtruth heading_direction obtained from the server.
:return: heading direction with noise.
`add_speed_noise(self, speed)`
: Add gaussian white noise to the current speed.
Args:
speed (float): m/s, current speed.
Returns:
float: the speed with noise added.
`destroy(self)`
: Destroy the sensors
:return:
`get_ego_pos(self)`
: Retrieve ego vehicle position
:return: vehicle position
`get_ego_spd(self)`
: Retrieve ego vehicle speed
:return:
`localize(self)`
: Currently implemented in a naive way.
:return:
opencda.core.sensing.perception¶
The perception functions are implemented in this class.
opencda.core.senesing.perception.o3d_lidar_libs¶
Utility functions for 3d lidar visualization and processing by utilizing open3d.
Functions
o3d_camera_lidar_fusion(objects, yolo_bbx, lidar_3d, projected_lidar, lidar_sensor)
: Utilize the 3D lidar points to extend the 2D bounding box from camera to 3D bounding box under world coordinates.
Args:
objects (dict): The dictionary contains all object detection result.
yolo_bbx (torch.Tensor): Object detection bounding box at current photo from yolov5,
shape:(n, [x1, y1, x2, y2, label]).
lidar_3d (np.ndarray): Raw 3D lidar points in lidar coordinate system.
projected_lidar (np.ndarray): 3D lidar points projected to the camera space.
lidar_sensor (carla.Sensor): The lidar sensor.
Returns:
objects: dict
The update object dictionary that contains 3d bounding boxes.
o3d_pointcloud_encode(raw_data, point_cloud)
: Encode the raw point cloud to Open3d PointCloud object.
Args:
raw_data (np.ndarray): Raw lidar points (N, (x, y, z, i)) obtained from lidar sensor.
point_cloud (o3d.PointCloud): Open3d PointCloud.
Returns:
(o3d.PointCloud): PointCloud with added points.
o3d_visualizer_init(actor_id)
: Initialize the visualizer.
Args:
actor_id (int): Vehicle’s id.
Returns:
(o3d.visualizer): Initialize Open3d visualizer.
o3d_visualizer_show(vis, count, point_cloud, objects)
: Visualize the point cloud at runtime.
Args:
vis (o3d.Visualizer): Visualization interface.
count (int): current step since simulation started.
point_cloud (o3d.PointCLoud): Open3d point clouds.
objects (dict): The dictionary containing objects.
Returns:
opencda.core.senesing.perception.obstacle_vehicle¶
Obstacle vehicle class to save object detection results.
Functions
is_vehicle_cococlass(label)
: Check whether the label belongs to the vehicle class according to coco dataset.
Args:
label(int):
Returns:
is_vehicle: bool
whether this label belongs to the vehicle class
Classes
BoundingBox(corners)
: Bounding box class for obstacle vehicle.
Construct class.
Args:
corners (nd.nparray): Eight corners of the bounding box. shape:(8, 3)
ObstacleVehicle(corners, o3d_bbx, vehicle=None, lidar=None)
: A class for obstacle vehicle. The attributes are designed to match with carla.Vehicle class
Construct class.
Args:
corners (nd.nparray): Eight corners of the bounding box. shape:(8, 3).
o3d_bbx (open3d.AlignedBoundingBox): The bounding box object in Open3d. This is mainly used for
visualization.
vehicle(carla.Vehicle): carla.Vehicle object.
lidar(carla.sensor.lidar): lidar sensor.
### Methods
`get_location(self)`
:
`get_transform(self)`
:
`get_velocity(self)`
:
`set_vehicle(self, vehicle, lidar)`
: Assign the attributes from carla.Vehicle to ObstacleVehicle
Args:
vehicle(carla.Vehicle): carla.Vehicle object.
lidar(carla.sensor.lidar): lidar sensor, used to project world coordinates to sensor coordinates.
Returns:
`set_velocity(self, velocity)`
: Set the velocity of the vehicle.
Args:
velocity(carla.Vector3D): velocity in 3d vector format.
Returns:
StaticObstacle(corner, o3d_bbx)
: Currently, we regard all static obstacles such as stop signs and traffic light as the same class.
Construct class.
Args:
corner (nd.nparray): Eight corners of the bounding box. shape:(8, 3)
o3d_bbx (open3d.AlignedBoundingBox): The bounding box object in Open3d. This is mainly used for
visualization.
opencda.core.senesing.perception.perception_manager¶
Manager class for the perception module.
Classes
CameraSensor(vehicle, position='front')
: Class for rgb camera.
Construct class.
Args:
vehicle (carla.Vehicle): Carla actor.
position (string): the camera mounted position, only front, left and right supported.
LidarSensor(vehicle, config_yaml)
: Lidar sensor manager.
Construct class.
Args:
vehicle (carla.Vehicle): The attached vehicle.
config_yaml (dict): Configuration for lidar.
PerceptionManager(vehicle, config_yaml, ml_manager)
: Perception manager mainly for object detection
Construct class.
Args:
vehicle (carla.Actor): The carla vehicle.
config_yaml (dict): The configuration yaml dictionary.
ml_manager(MlManager): Machine learning manager from CAV World.
### Methods
`activate_mode(self, objects)`
: Use Yolov5 + Lidar fusion to detect objects.
Args:
objects(dict): object dictionary
Returns:
objects: dict
The updated object dictionary.
`deactivate_mode(self, objects)`
: Obstacle detection under perception deactivation mode.
Args:
objects(dict): object dictionary
Returns:
`destroy(self)`
: Destroy sensors.
Returns:
`detect(self, ego_pos)`
: Detect surrounding objects. Currently only vehicle detection supported.
Args:
ego_pos (carla.Transform): Vehicle ego position
Returns:
List of carla.Vehicle or ObstacleVehicle
`dist(self, v)`
: A fast method to retrieve the obstable distance the ego vehicle from the server directly.
Args:
v (carla.vehicle):
Returns:
float: distance
`speed_retrieve(self, objects)`
: We don't implement any obstacle speed calculation algorithm. The speed will be retrieved from
the server directly.
Args:
objects(dict): The dictionary contains the objects.
Returns:
`visualize_3d_bbx_front_camera(self, objects, rgb_image)`
: Visualize the 3d bounding box on frontal camera image.
Args:
objects (dict): a dictionary containing all detected objects.
rgb_image (np.ndarray):camera image.
Returns:
opencda.core.senesing.perception.sensor_transformation¶
Class that contains the transformations between world and different sensors.
Variables
VID_RANGE
: Part 1: Camera Related Transformation
Functions
bbx_to_world(cords, vehicle)
: Convert bounding box coordinate at vehicle reference to world reference.
Args:
cords (np.ndarray): Bounding box coordinates with 8 vertices.
vehicle (carla.vehicle or ObstacleVehicle): vehicle object.
Returns:
bb_world_cords: np.ndarray
Bounding box coordinates under word reference.
create_bb_points(vehicle)
: Extract the eight vertices of the bounding box from the vehicle.
Args:
vehicle (carla.Vehicle or ObstacleVehicle):
Returns:
(np.ndarray): 3d bounding box.
get_2d_bb(vehicle, sensor, senosr_transform)
: Summarize 2D bounding box creation
Args:
vehicle (carla.vehicle or ObstacleVehicle): vehicle object.
sensor (carla.sensor.camera.rgb): The CARLA sensor object.
senosr_transform (carla.Transform): sensor position in the world
Returns:
(np.ndarray): 2d bounding box in camera image
get_bounding_box(vehicle, sensor, sensor_transform)
: Get vehicle bounding box and project to sensor image
Args:
vehicle (carla.vehicle or ObstacleVehicle): vehicle object.
sensor (carla.sensor.camera.rgb): The CARLA sensor object.
sensor_transform (carla.Transform): sensor position in the world
Returns:
(np.ndarray): Bounding box coordinates in sensor image.
get_camera_intrinsic(sensor)
: Retrieve the camera intrinsic matrix
Args:
sensor (carla.sensor.camera.rgb): The CARLA sensor object.
Returns:
np.ndarray: 2D intrinsic matrix
p3d_to_p2d_bb(p3d_bb)
: Draw 2D bounding box (4 vertices) from 3D bounding box (8 vertices) in image.
2D bounding box is represented by two corner points
Args:
p3d_bb ():
Returns:
project_lidar_to_camera(lidar, camera, point_cloud, rgb_image)
: Project lidar to camera space.
Args:
lidar (carla.Sensor): Lidar sensor.
camera (carla.Sensor): Camera seonsor.
point_cloud (np.ndarray): cloud points, (x, y, z, intensity).
rgb_image (np.ndarray): rgb image from camera.
Returns:
(np.ndarray): new rgb image with lidar points projected.
(np.ndarray): point clouds projected to camera space.
sensor_to_world(cords, sensor_transform)
: Project
Args:
cords (np.ndarray): Coordinates under sensor reference.
sensor_transform (carla.Transform): sensor position in the world
Returns:
world_cords: np.ndarray
Coordinates projected to world space.
vehicle_to_sensor(cords, vehicle, sensor_transform)
: Transform coordinates from vehicle reference to sensor reference
Args:
cords (np.ndarray): Coordinates under vehicle reference, shape (4, n)
vehicle (carla.vehicle or ObstacleVehicle): vehicle object.
sensor_transform (carla.Transform): sensor position in the world, shape(3, 1)
Returns:
(np.ndarray): Coordinates in sensor reference.
world_to_sensor(cords, sensor_transform)
: Transform coordinate from world reference to sensor reference.
Args:
cords (np.ndarray): Coordinates under world reference, shape:(4, n).
sensor_transform (carla.Transform): sensor position in the world, shape:(3, 1).
Returns:
sensor_cords: np.ndarray
Coordinates in sensor reference.
x_to_world_transformation(transform)
: Get the transformation matrix from x(it can be vehicle or sensor) coordinates to world coordinate.
Args:
transform (carla.Transform): The transform that contains location and rotation.
Returns:
matrix: np.ndarray
The transformation matrix
OpenCDA Module: customize¶
This is the module that handles customized content (i.e., controllers, learning methods, etc.).
opencda.customize.ml_libs¶
The manager class for machine learning libraries.
opencda.customize.ml_libs.ml_manager¶
Since multiple CAV normally use the same ML/DL model, here we have this class to enable different CAVs share the same model to avoid duplicate memory consumption.
Variables
MLManager()
: A class that should contain all the ML models you want to initialize.
Construction class.
### Methods
`draw_2d_box(self, result, rgb_image, index)`
: Draw 2d bounding box based on the yolo detection.
Args:
result (yolo.Result):Detection result from yolo 5.
rgb_image (np.ndarray): Camera rgb image.
index(int): Indicate the index
Returns:
(np.ndarray): camera image with bbx drawn.
OpenCDA Module: scenario_testing¶
This is the module that regulates all the scenario related python scripts, utility functions and configuration files. Scenario defination scripts locate at this directory.
config_yaml¶
Directory
This is the directory that contains configuration files for each scenario.
opencda.scenario_testing.evaluations¶
Class for scenario evalution functions.
opencda.scenario_testing.evaluations.evaluate_manager¶
The manager class for scenario evaluation.
Class
EvaluationManager(cav_world)
: Evaluation manager to manage the analysis of the results for different modules.
Construct class
Args:
cav_world (opencda.CavWorld): The CavWorld object that contains all CAVs' information
### Methods
`evaluate(self)`
: Evaluate performance of all modules by plotting and writing the statistics into the log file.
Returns:
`kinematics_eval(self, log_file)`
: vehicle kinematics related evaluation.
Args:
log_file (File): The log file to write the data.
Returns:
`localization_eval(self, log_file)`
: Localization module evaluation.
Args:
log_file (File): The log file to write the data.
Returns:
`platooning_eval(self, log_file)`
: Platooning evaluation.
Args:
log_file (File): The log file to write the data.
Returns:
opencda.scenario_testing.evaluations.evaluate_manager¶
Utility functions for evaluation.
Functions
lprint(logfile, *argv)
: Save string to log file.
Args:
logfile (File): The log file path.
*argv (string or number): the string that needs to be saved into the log file.
Returns:
opencda.scenario_testing.utils¶
Module for scenario related utility functions.
opencda.scenario_testing.utils.customized_map_api¶
Loading world from customized map
Functions
load_customized_world(xodr_path, client)
: Load .xodr file and return the carla world object
:param xodr_path: path to the xodr file
:param client: created client
:return:
spawn_helper_2lanefree(carla_map, coefficient)
: A helper function to locate the valid spawn point on the merge lane.
:param carla_map: the 2lanefreeway map
:param coefficient: a single scalar indicating where is the spawn point, eg. 0.5 represents the spawn position
is in the middle of the merge lane
:return: carla transform
spawn_helper_2lanefree_complete(carla_map, coefficient)
: A helper function to locate the valid spawn point on the merge lane.
:param carla_map: the 2lanefreeway map
:param coefficient: a single scalar indicating where is the spawn point, eg. 0.5 represents the spawn position
is in the middle of the merge lane
:return: carla transform
Classes
bcolors()
:
Class variables¶
BOLD
:
ENDC
:
FAIL
:
HEADER
:
OKBLUE
:
OKCYAN
:
OKGREEN
:
UNDERLINE
:
WARNING
:
opencda.scenario_testing.utils.sim_api¶
Simulation API for create simulation world, vehicle manager and so on.
Functions
car_blueprint_filter(blueprints)
: Filter out the uncommon vehicles
:return:
createPlatoonManagers(world, carla_map, scenario_params, apply_ml, map_helper=None)
: Create Platooning Managers based on given params.
Args:
world (carla.World): World from CARLA simulator.
carla_map (carla.Map): Map obtained from CARLA server.
scenario_params (dict): Platoon paramters.
apply_ml (bool): whether ml/dl model is included. Pytorch/sklearn required to install if set to true.
map_helper (function): Specific function to convert certain parameters to spawn position in certain map.
Returns:
platoon_list list (list)
cav_world (carla.World)
createSimulationWorld(simulation_config, xodr_path=None, town=None)
: Create client and simulation world
:param simulation_config: configuration dictionary for simulation
:param xodr_path: optional, used only when customized map needed
:param town: default town name if not using customized map, eg. ‘Town06’
:return: client, simulation world, origin setting
createTrafficManager(client, world, traffic_config)
: Create background traffic
:param client:
:param world:
:param traffic_config:
:return:
createVehicleManager(world, scenario_params, application, cav_world, carla_map, map_helper=None)
: Create single CAV manager
:param world: simulation world
:param scenario_params: scenario configuration
:param application: the application purpose, a list, eg. [’single’]
:param cav_world: object containing all cav info
:param carla_map: carla HD Map
:param map_helper: A function used for conveniently set the spawn position depending on different maps
:return: a list of vehicle managers
destroyActors(world)
: Destroy all actors in the world
:param world:
:return:
opencda.scenario_testing.utils.yaml_utils¶
Used to load and write yaml files.
Functions
load_yaml(file)
: load yaml file and return a dictionary
:param file: yaml file path
:return: a dictionary that contains defined parameters
Note: The current OpenCDA Module is developed specificlly for OpenCDA version 1.0, please refer to the corresponding software version.


While this is not my first website, it has been several years since I have created a website so. Lets start from the beginning.


Drag and drop items to this Venn diagram!
Reset
Attempts Remaining:
Eukaryotic Cell
Prokaryotic Cell
Word Bank
Flagella
Cytoplasm
Nucleus
Organelle
Mitochondria
Ribosome
Golgi Apparatus
Pili
Plasma membrane
Endoplasmic Reticulum
Submit


Go to the source code of this file.
◆ CORR_OUTPUT_BITS
| #define CORR_OUTPUT_BITS 15 |
◆ CORRELATOR
| #define CORRELATOR GnssHw4Correlator |
◆ GNSS_HW_FREQ_HZ
| #define GNSS_HW_FREQ_HZ 81000000ul |
◆ GNSS_INTERMEDIATE_FREQ_ACQ_L1E1_HZ
| #define GNSS_INTERMEDIATE_FREQ_ACQ_L1E1_HZ -9580000 |
◆ GNSS_SAMPLING_FREQ_HZ
◆ MAX_NR_OF_HW_CHANNELS
| #define MAX_NR_OF_HW_CHANNELS 61 |
◆ NR_OF_CORRELATION_POINTS
| #define NR_OF_CORRELATION_POINTS 5 |
◆ NR_OF_DUMMY_CORRELATORS
| #define NR_OF_DUMMY_CORRELATORS 1 |
◆ NR_OF_L1BAND_HW_CHANNELS
| #define NR_OF_L1BAND_HW_CHANNELS (61 - 1) / 3 |
◆ NR_OF_L2_E5_ALTBOC_HW_CHANNELS
| #define NR_OF_L2_E5_ALTBOC_HW_CHANNELS (61 - 1) / 3 |
◆ NR_OF_L5E5A_HW_CHANNELS
| #define NR_OF_L5E5A_HW_CHANNELS (61 - 1) / 3 |


--- layout: post title: Using git attributes to exclude files from your release header-img: "img/gitattributes/gitattributes.png" subtitle: "Exclude files from your exports" permalink: /article/using-git-attributes-exclude-files-your-release/ permalink-disqus: /article/using-git-attributes-exclude-files-your-release author: "Sean Hamlin" categories: - tutorial tags: - drupalplanet - git - code - release - deployment ---
Deploying your development codebase to production seems like it has been solved many different ways, and often those ways are terrible from a security perspective.
Quite possibly the worst idea ever, as not only is every single file on the production web servers, also every single revision of every single file is on the web server. Even worse, if the root .git
directory is accessible over HTTP, the whole website can be cloned over HTTP as well.
Yes you can remove the .git
directory, but this will not solve all your problems.
One step better is to create just a snapshot of the repository using git archive. You can create a snapshot easily using git archive
git archive master -o latest.zip
git archive master | bzip2 -9 > latest.tar.bz2
this will still contain files you do not want on the webserver, e.g.
We have recently switched to using git attributes on all releases to ensure only the needed files for production are sent there during a release.
Here is a sample git attributes file that we use for Drupal 7:
# used to remove files from deployment using `git archive` # git files .gitattributes export-ignore .gitignore export-ignore # drush files build.make export-ignore patches.txt export-ignore # zen 5.x files sites/all/themes/*/sass export-ignore sites/all/themes/*/sass-extensions export-ignore sites/all/themes/*/images-source export-ignore sites/all/themes/*/fonts export-ignore sites/all/themes/*/config.rb export-ignore sites/all/themes/*/STARTERKIT export-ignore # drupal directories scripts export-ignore profiles/minimal export-ignore profiles/standard export-ignore profiles/testing export-ignore # general text files *README.txt export-ignore *readme.md export-ignore *README.md export-ignore *README export-ignore *LICENSE.txt export-ignore *license.txt export-ignore *LICENSE.html export-ignore COPYRIGHT.txt export-ignore CHANGELOG.txt export-ignore *changelog.txt export-ignore *changelog.html export-ignore *CHANGES.html export-ignore *INSTALL.html export-ignore *TODO.txt export-ignore *API.txt export-ignore *api.html export-ignore *KNOWN_ISSUES.txt export-ignore UPGRADE.txt export-ignore web.config export-ignore MAINTAINERS.txt export-ignore INSTALL*.txt export-ignore # patches *.patch export-ignore # tests *.test export-ignore # contrib (these could be security holes) sites/all/libraries/plupload/examples export-ignore sites/all/libraries/plupload/docs export-ignore sites/all/libraries/jquery.jcarousel/examples export-ignore sites/all/libraries/jquery.jcarousel/index.html export-ignore sites/all/libraries/jquery.jcarousel/style.css export-ignore sites/all/libraries/jquery.jcarousel/skins export-ignore sites/all/libraries/jquery.jcarousel/lib/jquery.jcarousel.js export-ignore sites/all/libraries/jquery.jcarousel/lib/jquery-1.4.2.min.js export-ignore sites/all/libraries/colorbox/colorbox.ai export-ignore sites/all/libraries/colorbox/*/*.html export-ignore sites/all/libraries/colorbox/content export-ignore sites/all/libraries/colorbox/jquery.colorbox.js export-ignore sites/all/modules/contrib/ckeditor/images/buttons/index.html export-ignore sites/all/modules/contrib/openlayers/tests/js/qunit/index.html export-ignore
The sample git attributes file is rather long and exhaustive, and it covers a wide range of core and contributed modules for Drupal 7. The plupload module is especially dangerous, as the library actually comes with several PHP scripts that if your webserver allowed it to execute, it would allow anyone (anonymous included) to upload unlimited files to the webserver.
You could take the export to the next level and remove several core PHP files from the release like:
If you have any suggestions for improvements, let me know in the comments.


(As foreseen by Mr. Punch's Second-sighted Clairvoyant.)
It is the summer of 1896—or possibly '97. The scene is a road skirting Victoria Park, Bethnal Green, which Society's leaders have recently discovered and appointed as the rendez-vous for the Season, and where it is now the correct thing for all really smart people to indulge, between certain prescribed hours, in sports and pastimes that have hitherto been more characteristic of the masses than the classes. The only permissible mount now is the donkey, which must be ridden close to the tail, and referred to as a "moke." A crowd of well-turned-out spectators arrives from the West End every morning about eleven to watch the brilliant parade of "Mokestrians" (as the Society journalist will already have decided to call them). Some drive slowly up and down on coster-barrows, attended by cockaded and disgusted grooms. About twelve, they break up into light luncheon parties; after which they play democratic games for half an hour or so, and drive home on drags.
Mr. Woodby-Innett (to the Donkey Proprietor). Kept a moke for me? I told you I should be wantin' one every mornin' now.
The Donkey Proprietor (after consulting engagement-book). I've not got it down on my list, Sir. Very sorry, but the Countess of Cumberback has just booked the last for the 'ole of this week. Might let you 'ave one by-and-by, if Sir Hascot Goodwood brings his in punctual, but I can't promise it.
Mr. Woodby-Inn. That's no good; no point in ridin' after the right time. (To himself, as he turns away.) Nuisance! Not that I'm so keen about a moke. Not a patch on a bike!—though it don't do to say so. Only if I'd known this, I'd have turned up in a tall hat and frock coat; and then I could have taken a turn on the steam-circus. Wonder if it would be any sort of form shyin' at cocoa-nuts in tweeds and a straw hat. Must ask some chap who knows. More puzzlin' what to put on this year than ever!
Lady Ranela Hurlingham (breathlessly to Donkey Proprietor). That's mine, isn't it? Will you please put me up, and promise me you'll keep close behind and make him run. (Suppliantly.) You will, won't you?
The Donkey Proprietor (with a due sense of his own value). Well, I dessay I can come along presently, Lady 'Urlingham, and fetch 'im a whack or two; jest now I can't, having engaged to come and 'old the Marshiness of 'Ammercloth's on 'er moke; but there, you orter be able to git along well enough by yourself now—you ought!
Captain Sonbyrne (just home on leave from India—to Mrs. Chesham-Lowndes). Rather an odd sort of idea this—I mean, coming all the way out here to ride a lot of donkeys, eh?


{% include head.html %}
This link is outdated, please click me to go to the correct page!
{% include footer.html %} {% include otherprojmodals.html %} {% include javascript.html %}


form elements Here are all forms elements cross browser styled. Budget 1000$ 2000$ 3000$ 5000$+ Attach a file Tech HTML5 jQuery Wordpress Gender male female


This is a exercise to build a line graph component using only Typescript and vanilla Javascript.
Bootstrap was the only framework brought into the project for quick styling changes.


--- layout: components title: Table current: table ---
An extension of GOVUK table with additional options.
Sorting should work with JavaScript off. The JavaScript used here to display styles is not production ready.
{% include example.html component="table" example="sortable" size="s" %}For full width tables where the number of columns causes layout problems.
{% include example.html component="table" example="condensed" size="m" %}Flip axis on tables to accommodate smaller screen sizes.
{% include example.html component="table" example="responsive" size="m" %}


Interface Module
Files
Interface/interface.cm
Classes
public
class
ConsoleWriter
public
class
StringReader
Interfaces
public
interface
Reader
public
interface
Writer
Functions
public
void
Copy
(
Reader
reader,
Writer
writer)
void
main
()
Function Details
Copy Function
public
void
Copy(
Reader
reader,
Writer
writer)
Definition
Line
14
of
Interface/interface.cm
main Function
void
main()
Definition
Line
57
of
Interface/interface.cm


Recently I got an itch to practice some backend fundamentals, and set up a few different stacks from scratch. First up is Rails, something I’ve worked with in the past and know to be a very well automated full stack solution. I’ve used Ruby since 1.8.7, so am comfortable with the language.
Setting up the stack, however, is still a process I have not mastered. I hit several roadblocks along the way to getting a working Rails app running, as is tradition harkening back to every other time I’ve attempted it. Working with the Ruby ecosystem is complicated enough that a Homebrew formula was created to encapsulate installing the CocoaPods gem, which has been another plentiful source of adventure for me while working on iOS.
This time, I started by following Heroku’s guide and hit two problems: installing nokogiri and pg, both with native extensions. I waded through an ocean of GitHub issues and Stack Overflow posts to cobble something together that finally worked. So, I’ll add my drops of knowledge to that yawning abyss. Here is a list of everything I did until I got a successful Rails app running locally.
rbenv install 2.5.1
rbenv rehash
rbenv local 2.5.1
rbenv exec gem install bundler
rbenv exec bundle config --global path vendor/bundle
# from this GitHub Gist; I like this model of keeping all dependencies in the project, instead of user/global directories, just like CocoaPodsbrew install libxml2 pkg-confif
brew uninstall --ignore-dependencies xz
xcode-select -switch
between my local versions of Xcode 10 and 9.4.1env ARCHFLAGS="-arch x86_64" rbenv exec bundle
# ARCHFLAGS workaround for pg gem: https://stackoverflow.com/questions/6209797/cant-find-the-postgresql-client-library-libpq)brew install xz
# don’t forget this if you uninstalled it earlier!Steps 4 and 5 are where I hit trouble. When bundling, I got some error messages about undefined symbols for the i386 architecture when building nokogiri with native extensions. I couldn’t find anything on the web pointing out my exact problem, but many similar ones, so I chipped away by trying a few different things I found. (I must admit that I don’t know which one alone would have fixed it. I tried resetting my machine and retracing all these steps again, only to have it work perfectly without hitting the same nokogiri issues.) The linked SO post in step 4 is the exact problem I had and I was able to translate the top solution for my needs (by removing sudo
usage and replacing it with rbenv
).
From here it wasn’t too much more to get to running the app in the cloud via Heroku. I had to fill in some steps of my own to get it working though–their guide did not have adequate coverage of local PostgreSQL usage. When I tried to run rbenv exec bundle exec rails server
I got a fatal exception: database "myapp_development" does not exist
. The GoRails guide filled in the gap there, where I’d hadn’t yet run rails db:create
. I also wound up needing to do the following for that to work:
brew install postresql
createdb
Finally, rerunning the Rails server was able to get me to the Heroku tutorial’s welcome controller page. Whew… I have a working Rails app again! I committed it to a GitHub repo for preservation.
Funnily enough, I blew away some Ruby dependencies I use to compile this static site with Jekyll, Sass and a few plugins! I fixed it up, and it now uses the local vendor/bundle
bundler path as well, and I even ran bundle package
and checked bundle/cache
into source control, while adding bundle/vendor/**/*
to .gitignore
(thanks to this guide to bundler dependencies, which also enunciates dependency principles that resonate strongly with me; see also my previous writings on dependency isolation).
🙏🏻 Enjoy the post? Please help support more like it by buying me a cup of coffee!.
💡 Suggestions, questions, comments? Please submit a PR!.


Less Arctic ice sees polar bears near Russian village
by AFPMore than 50 polar bears have gathered on the edge of a village in Russia’s far north, environmentalists and residents said, as weak Arctic ice leaves them unable to roam.
The Russian branch of the World Wildlife Fund said climate change was to blame, as unusually warm temperatures prevented coastal ice from forming.
The WWF said 56 polar bears had gathered in a 1 sq km area near the village of Ryrkaipy in Chukotka on the northeastern tip of Russia.
There were concerns they could enter the village, home to fewer than 1,000 people, and patrols had been set up to monitor their movements.
“The number of human and predator encounters in the Arctic is increasing,” the WWF said in a statement.
“The main reason is the decline of sea ice area due to the changing climate. In the absence of ice cover, animals are forced to go ashore in search of food.”
Residents had gathered walrus carcasses in the area to try to keep the bears from wandering into the village.
“We have created a feeding point with walrus carcasses that we gathered along the coast,” Tatyana Minenko of the local “Bear Patrol” told news agency RIA Novosti.
“As long as there is no big freeze, the sea ice will not form and the bears will stay on the coast,” she said.
Russia’s weather service said temperatures in the region should fall from Saturday and that coastal ice should freeze by Wednesday.
Polar bears regularly visit areas inhabited by humans in Arctic Russia to search for food, often in rubbish tips.
But the number of visits has been growing as the melting of Arctic ice from climate change forces the bears to spend more time on land where they compete for food.


{% macro render_field(field, label_visible=true) -%} {% if field.type != 'HiddenField' and label_visible %} {{ field(class_='form-control', **kwargs)|safe}} {% if field.errors %} {% for e in field.errors %}
English
+58<PHONE_NUMBER>
Please confirm your password
All items are required, make sure to provide the correct information since it will be taken into account for your application evaluation.


Please fill the below persoanl information and we will get in touch shortly...☺
What Photgraphy would you like to learn
In What duration would like to complete the course
Following are the Fee Structures
04 Months - 5000$
06 Months - 4000$
08 Months - 3500$

          Contact US:
    H.No:605,
North Market,
    MaryVille,
    Missouri - 64468.
    Ph:<PHONE_NUMBER>.


acrostic-talk.pdf
by author, 100 pages, 2018
argumentation-cross-domain-talk.pdf
by author, 9 pages, 2018
cicling14-talk.pdf
by author, 14 pages, 2018
cikm13-talk.pdf
by author, 19 pages, 2018
eurovis15-plagvis-talk.pdf
by author, 63 pages, 2018
ijcnlp13-talk.pdf
by author, 13 pages, 2018
jufo13-talk.pdf
by author, 22 pages, 2018
leipzig-colloquium15-talk.pdf
by author, 118 pages, 2018
netspeak-talk.pdf
by author, 45 pages, 2018
ral15-picapica-talk.pdf
by author, 82 pages, 2018
An x symbol representing a closing action
Help
Document-specific controls
Shortcut
Documents
↑/↓
Navigate documents
Shift
+
↑/↓
Navigate 3 documents
Page-specific controls
Shortcut
Pages
←/→
Navigate pages
Shift
+
MouseWheel
Navigate pages
Shift
+
←/→
Navigate 3 pages


obs_shape = ((len(observations), ) +
self._env_spec.observation_space.shape)
observations = observations.reshape(obs_shape)
return super().forward(observations)
out = self._module(observations)
val = self._val(out)
act = self._act(out)
act = act - act.mean(1).unsqueeze(1)
return val + act


Concrete
Allism Construction services is a well-established construction company that has extensive experience in architectural concrete and formwork design in both the domestic and commercial sectors. Our company specialises in exposed aggregate, coloured and plain concrete driveways, plus pathways and entertaining areas; offering an extensive range of products. If you have a slab or garage slab that needs doing, we have a great crew to take on any project to a very high standard. House & Garage slabs require formwork and concrete pumps. We organize everything for the job and always work with the owner/manager to ensure that the project is planned and completed in time. If you’re looking for concreters in Melbourne that you can trust, we are here to help”
Asphalt Work
At Allism , we specialise in all forms of asphalt & civil construction, asphalt repairs and maintenance. To enhance your project we also supply & install associated edging at your request including brick, timber, bluestone, concrete (coloured or plain)
Excavations
We provide all types of bulk excavation, cut and fill earthmoving for domestic, commercial and industrial/government projects. We have all the plant and machinery for massive bulk excavations, including excavations, tippers and all the earthmoving plant your project needs. We have trained staff and estimators to assist in project management of your project, including estimating and calculating volumes, time frames and schedules to ensure your construction project runs smoothly and most importantly to budget. With our extensive knowledge of the Melbourne suburbs and all of Victoria, we can provide an all-round service, from digging to removing of spoil. Our trained staff and company put customer satisfaction first. Not only do we aim at finishing your project as soon as possible, but we also focus on providing a clean and safe job site whilst we are completing your project.”
Telecom Networks
ACS offers construction and installation of pit and pipe, rectification works, network relocation, exchanges, and lead in conduits. Our construction team specialise in telecommunications and are well versed in the current regulations. ACS has been building telecommunications networks for more than 10 years now. In recent times ACS has been involved in the roll out of the National Broadband Network into new estates.
About
2009-2011
Lorem ipsum dolor sit amet, consectetur adipisicing elit. Sunt ut voluptatum eius sapiente, totam reiciendis temporibus qui quibusdam, recusandae sit vero unde, sed, incidunt et ea quo dolore laudantium consectetur!
March 2011
Lorem ipsum dolor sit amet, consectetur adipisicing elit. Sunt ut voluptatum eius sapiente, totam reiciendis temporibus qui quibusdam, recusandae sit vero unde, sed, incidunt et ea quo dolore laudantium consectetur!
2019
Ravi Riley converted Agency, a Bootstrap-based theme, into a Jekyll theme. The Jekyll theme can be installed as a Ruby gem, or remotely. For more information, visit the documentation.
2009-2011
Your description here, Markdown is fully supported.
Lead Designer
Chief Executive
Lead Developer
Lorem ipsum dolor sit amet, consectetur adipisicing elit. Aut eaque, laboriosam veritatis, quos non quis ad perspiciatis, totam corporis ea, alias ut unde. Markdown supported.
Contact Us


SURPRISE SHIPPING NEWS: WE’VE EXTENDED THE DEADLINE FOR STANDARD HOLIDAY DELIVERY
TO 11PM EST TODAY. (TWO DAYS LEFT FOR EXPEDITED HOLIDAY DELIVERY.)*
ENDS TODAY:
30% OFF
EVERY PURCHASE,
IN STORES & ONLINE
PLUS, FREE SHIPPING ON $100+.**
USE CODE CELEBRATE.
GET GIFTS FOR WOMEN, MEN, GIRLS & BOYS
*To ensure delivery by December 24, 2012, orders for U.S. shipments must be placed by December 20, 2012, at 11pm EST for standard ground shipping and by December 22, 2012, at 12pm/noon EST for expedited shipping. Holiday delivery cannot be guaranteed for shipments to Alaska, Hawaii, Puerto Rico, APO/FPO and P.O. Boxes (click here for shipping and handling rates and details).
**Offer valid on purchases made in J.Crew stores and at jcrew.com from December 18, 2012, 12:01am ET through December 20, 2012, 11:59pm ET only. Offer not valid in J.Crew Factory stores; at jcrewfactory.com; at the Ludlow Shop at 50 Hudson or the Ludlow Shop at Copley Place; or on phone orders. Offer cannot be applied to previous purchases or the purchase of gift cards and cannot be redeemed for cash or combined with any other promotion. Discount on retail purchases will be applied at the register. To redeem online, enter code CELEBRATE in the promo box at checkout. Discount not valid on purchases of certain third-party branded merchandise, baby merchandise, men’s suiting or online purchases of wedding merchandise. Free shipping valid for shipments to the U.S. and Canada on orders of $100 or more, before taxes are added, shipped via regular ground shipping (3 to 6 business days) only. Terms of offer are subject to change.
To subscribe from the email list, click here.
http://e.jcrew.com/a/tBQ0wwyBgTeL6B8vzqSNs5LxiZY/sub-12?d_source=EMSL06560
To unsubscribe from the email list, click here.
<EMAIL_ADDRESS>J.Crew Customer Relations | One Ivy Crescent | Lynchburg, VA 24513-1001


Toggle navigation
Home
Services
History
Location
Contact
Malankara Catholic Mission
Edmonton
Send us a Message
Vicar
Fr. Thomas Puthuparambil,
10044 113 Street NW,
Edmonton, AB T5K 1N8.
Full Name:
Phone Number:
Email Address:
Subject:
Message:
Send Message


Thank you for participating in our study!
With this short debriefing we want to inform you about the goal of our study and why you had to answer these questions.
Follow-up research on the Prospect Theory by Kahnemann and Tversky suggests that there is a linkage between emotions and risk-taking behaviour.
This experiment aimed on contributing to this research by putting you in a certain emotional state and test your risk aversion afterwards. To be more
precise we have 3 hypotheses:
H1: Putting participants in a sad emotional state increases their risk aversion
H2: Putting participants in an angry emotional state increases their risk affinity
H3: Putting participants in a fearful emotional state increases their risk aversion
To observe the effects we are interested in, it was unfortunately necessary to manipulate your emotional state for a short amount of time.
We put you in the certain emomtional state by letting you complete the writing task where you had to report from a emotional situation in your life. You were randomnly assigned to one of the emotional conditions. With the measurement of mood prior and after the writing task we checked changes in your emotional state. After that,
we observed your risk-taking behavior in the small gambling game. The other questions only served the purpose to distract you from the real goal of our study to avoid bias.
We hope that this information helps you to realize that you should not further feel sad, angry or fearful and leave the emotional state again. If not, please don't hesitate to
talk to someone or contact us. You can also contact us if you are interested in further information on our study.
By pressing the Done-Button you consent to the usage of your data you just gave and end the survey.
As mentioned in the beginning your data will be handled with strictest confidentiality and is used for scientific purposes only.


A comprehensive light controller for the MiLight bridge version 5. MiLight-Controller (working name) makes it possible to control your MiLight light bulbs and led strips from any device with a web browser.
This project is currently in a beta stage. Feedback would be greatly appreciated!


<paper-collapse-item>
Items can have an icon or an image
Lots of very interesting content.
Lots of very interesting content.
Lots of very interesting content.
Items can have HTML in their header
Lots of very interesting content.
Items fire events when they are toggled
Lots of very interesting content.
Item header and content can be styled
Lots of very interesting content.
<paper-collapse-group>
Item groups allow only one item to be opened
Only one item will be opened inside a group
Only one item will be opened inside a group
Only one item will be opened inside a group


DHHS has issued guidance regarding potential community exposure of the coronavirus after DHHS determined that a person with COVID-19 was on the following Concord Coach Lines buses:
Any individuals who rode on one of the Concord Coach Line buses above may have been potentially exposed to the novel coronavirus and should stay at home and monitor their health for fever or respiratory illness. Any person who was on those buses and has developed symptoms should stay away from other people, and immediately contact their healthcare provider. View the DHHS Guidance for Self-Quarantine…
A novel coronavirus (COVID-19) has been identified as the cause of an outbreak of respiratory illness first detected in Wuhan City, Hubei Province, China, and which continues to expand. Cases have been identified in the United States, as well as many other countries. The Centers for Disease Control and Prevention (CDC) and State and local health departments, including the New Hampshire (NH) Department of Health and Human Services (DHHS), Division of Public Health Services' (DPHS), are monitoring this rapidly developing situation. Information about this outbreak will be available here and continuously updated.
The update is dependent on the data not on the webpage update.
| Number of Persons with COVID-19 1 | 137 |
|---|---|
| Deaths Attributed to COVID-19 | 1 (<1%) |
| Hospitalizations | 19 (14%) |
| Persons Tested Negative at Selected Laboratories 2 | 3,001 |
| Persons with Specimens Submitted to NH PHL
|
2,620 |
| Persons with Test Pending at NH PHL 3 | 712 |
| Persons Being Monitored in NH (approximate point in time)
|
650 |
1Includes specimens presumptive-positive at any laboratory and those confirmed by CDC confirmatory testing.
2Includes specimens tested at the NH Public Health Laboratories (PHL), LabCorp, Quest, Dartmouth-Hitchcock Medical Center, and those sent to CDC prior to NH PHL testing capacity.
3
Portable Document Format (.pdf). Visit nh.gov for a list of free .pdf readers
New Hampshire Department of Health and Human Services


Reaction
To me, photography is an art of observation. It’s about finding something interesting an ordinary place...
Discover


--- layout: page title: About header-img: "img/about-bg.png" ---
This is journal to track the ups and downs of a career changer to coder.


We used the data set from UCI Default of Credit Card Clients data set to preditct the defult rate of a card application. The attributes of the data set include the serveral features:
X1: Amount of the given credit (NT dollar): it includes both the individual consumer credit and his/her family (supplementary) credit.
X2: Gender (1 = male; 2 = female).
X3: Education (1 = graduate school; 2 = university; 3 = high school; 4 = others).
X4: Marital status (1 = married; 2 = single; 3 = others).
X5: Age (year).
X6 - X11: History of past payment. We tracked the past monthly payment records (from April to September, 2005) as follows: X6 = the repayment status in September, 2005; X7 = the repayment status in August, 2005; . . .;X11 = the repayment status in April, 2005. The measurement scale for the repayment status is: -1 = pay duly; 1 = payment delay for one month; 2 = payment delay for two months; . . .; 8 = payment delay for eight months; 9 = payment delay for nine months and above.
X12-X17: Amount of bill statement (NT dollar). X12 = amount of bill statement in September, 2005; X13 = amount of bill statement in August, 2005; . . .; X17 = amount of bill statement in April, 2005.
X18-X23: Amount of previous payment (NT dollar).
X18 = amount paid in September, 2005; X19 = amount paid in August, 2005; . . .;X23 = amount paid in April, 2005.


Veteran Ascalon:
You have returned! How is Mason? Please tell me everything...
... You must tell me the truth!
...What! Never could I have imagined that he would be living a lonely, wretched life after losing all his family during the assault of Gracia... Perhaps his grief would be less severe now, since you have completed his revenge.
A Warrior must share the pain of his comrade, but still cannot stop fighting. It is time for you to fight once more.
"What is the next battle?"


Hubert Leo
Hi! I am current a student at Johns Hopkins University majoring in Computer Science. On the side I tutor high school students in Physics and Math and specialize in the IBDP curriculum. I also work as a freelance web developer specializing in the MEAN tech stack. I love contributing to companies with high impact projects.


FrameType GLUEEDITBOX
Like
EDITBOX
, but has the heavy mouse click Sound when created with BlzCreateFrame.


Sloppy PSG beaten by Dijon in Ligue 1
PARIS, Nov 1 — Paris St Germain suffered their third Ligue 1 defeat of the season when they wasted a one-goal lead to lose 2-1 at lowly Dijon yesterday.
Kylian Mbappe put the leaders ahead in the 19th minute before Dijon struck back with goals by Mounir Chouiar and Jhonder Cadiz to get a deserved victory.
PSG have 27 points from 12 games and lead second-placed Nantes, who travel to Girondins de Bordeaux tomorrow, by eight points.
Dijon, who have 12 points, are now 18th after starting the game at the bottom of the table.
Despite starting with their formidable trio of Mbappe, Mauro Icardi and Angel Di Maria, PSG played too casually and were eventually punished for their sloppiness.
Mbappe opened the scoring when he flicked the ball past Alfred Gomis after collecting a perfect through ball from Di Maria.
Thomas Tuchel’s side, however, were caught snoozing on the stroke of halftime as Keylor Navas parried a cross into the path of Chouiar, who pounced on the ball to equalize.
Two minutes into the second half, Cadiz powered his way into the box before slotting the ball between Navas’s legs to put the hosts ahead.
Tuchel replaced midfielder Leandro Paredes with striker Edinson Cavani in the 71st but the Uruguay international did little to show that he could regain his place in the starting line-up at the expense of Icardi.
“It’s a big upset, we had a great first half and had the chance to score early in the second half,” said Dijon captain Julio Tavares.
“We had to be at 200 per cent and we were.”
PSG’s Marquinhos, wearing the skipper’s armband in the absence of the ill Thiago Silva, admitted his side lacked aggression.
“It’s football. When you’re not present physically, not aggressive enough, that’s what happens,” the Brazilian said.
“We have to bounce back right away, we have to do much better. We should not stay in our comfort zone. We win when we’re efficient, in front and at the back.
“We can’t play like we did tonight.”
PSG next host Club Brugge in a Champions League group game on Wednesday. — Reuters


2. Foo
General description that will appear in the overview page and in the HTML reference and man page.
2.1. Foo definitions and functions
The foo(3) module ... in-depth description here (does not appear in the man page) ...
Foo definitions
Synopsis
#include <foo.h>
struct foo {
int n; /* members must be indented by a tab */
};
Description
Description of Foo definitions (does not appear in the man page) ...
The foo_bar function
Synopsis
#include <foo.h>
int foo_bar(struct foo *foo, int n);
Description
The foo_bar function ...
Returns
The foo_bar function returns 1 or 0 to indicate ...
Copyright 2004 Your Name Here <userid domain.com>


The user directory is where CONSTELLATION stores user-specific data such as auto-save files, icons, and delimited importer templates. By default the user directory is HomeDirectory/.CONSTELLATION.
You can open your user directory in your default file browser using the Help → User Directory menu.
If you want to change your user directory, create the new directory first, copy any files you want from the current directory to the new one, then change the directory in preferences.
By default, CONSTELLATION saves a copy of the graphs you're working on every five minutes. You can change this interval, or disable autosave altogether.
Select the default language to be used by the Scripting View. Default language options are:
CONSTELLATION is a java application which means that the memory management is handles by the Garbage Collector (GC) process inside the JVM (Java Virtual Machine). It is best left to the (GC) to decide when to release unused memory but we can give a hint to the (GC) to clear unused memory when a graph is open or closed.
The following options have been enabled by default and does not guarantee that any garbage collection will be performed because it is ultimately up to the (GC) process to decide. A side effect of having this enabled means that opening and closing graphs could take longer to complete if the (GC) decides to clean up unused memory on a open or close.
Verbose information like debug statements could be presented if this option is enabled. Only use this if you have been asked to enable this by CONSTELLATION support or a developer.


The Polymer element sets provide elements that you can use in your web pages and apps. These elements are built with the Polymer library.
You don't need to use Polymer directly to use these elements. However, using Polymer you can take advantage of special features such as data binding.
You can install elements one at a time, or install a whole collection of elements.
Polymer contains a few primary collections of elements:
Iron elements. A set of utility elements including generic UI elements (such as icons, input and layout components), as well as non-UI elements providing features like AJAX, signaling and storage.
Paper elements. A set of UI elements that implement the material design system.
Gold elements. Form elements for ecommerce.
Neon elements. Animation-related elements.
Platinum elements. Elements for app-like features, like push notifications, offline caching and bluetooth.
If you find a component you want while browsing the docs, simply click the
star
When you've selected some components, you can download either a bower.json
file or a ZIP file.
bower.json
file. Just the metadata you need to install the components using
Bower.
Bower is the recommended way to manage components. Bower also handles installing the components' dependencies and updating installed components. For more information, see Installing with Bower.
ZIP file. A single file containing your selected components and all their dependencies, so you can unzip and start using them immediately. The ZIP file requires no extra tools, but doesn't provide a built-in method for updating dependencies. For more information, see Installing from ZIP files.
To download the components in your collection:
Click
Choose a download format and click Download.
Pick your method and follow the instructions in the download dialog.
If you install one or more elements, you also get the Polymer library, as well as the web components polyfills, which allow you to run Polymer on browsers that don't yet support the web components standards.
The recommended way to install Polymer elements is through Bower. To install Bower, see the Bower web site.
Bower removes the hassle of dependency management when developing or consuming elements. When you install a component, Bower makes sure any dependencies are installed as well.
If you haven't created a bower.json
file for your application,
download the bower.json
from the catalog and edit it to add your
own project name and version.
If you already have a bower.json
file, merge the
dependencies
section of the downloaded file into your existing
bower.json
file.
The resulting file should look something like this:
{
"name": "my-project",
"version": "0.0.0",
"dependencies": {
"iron-a11y-keys": "PolymerElements/iron-a11y-keys#^1.0.0",
"iron-ajax": "PolymerElements/iron-ajax#^1.0.0",
"paper-button": "PolymerElements/paper-button#^1.0.0"
}
}
The next step is to install your selected components:
bower install
Bower adds a bower_components/
folder in the root of your project and
fills it with your selected elements and their dependencies.
You can also install components from the command line using the bower install
command.
You can also choose one of the commonly-used packages:
PolymerElements/iron-elements
PolymerElements/paper-elements
PolymerElements/gold-elements
For example:
bower install --save PolymerElements/iron-elements
When a new version of Polymer is available, run bower update
in your app directory to update your copy:
bower update
This updates all packages in bower_components/
.
When you download a component or component set as a ZIP file, you get all of the dependencies bundled into a single archive. It's a great way to get started because you don't need to install any additional tools.
Expand the ZIP file in your project directory to create a bower_components
folder.
Unlike Bower, the ZIP file doesn't provide a built-in method for updating dependencies. You can manually update components with a new ZIP file, or you can update the files using Bower.
If you downloaded a ZIP file and subsequently install Bower, you can
use bower init
to create a new bower.json
file with your existing
dependencies in it:
bower init
This generates a basic bower.json
file.
Enter Y when prompted to set currently installed components as dependencies.
Some of the questions, like "What kind of modules do you expose," can be skipped by pressing Enter.
To use elements, first load the web components polyfill library, webcomponents-lite.min.js
.
Many browsers have yet toimplement the various web components APIs. Until they do, webcomponents-lite
provides polyfill support. Be sure to include
this file before any code that touches the DOM.
Once you have some elements installed and you've loaded webcomponents-lite.min.js
,
using an element is simply a matter of loading the element file using an
HTML Import.
An example index.html
file:
<!DOCTYPE html>

<link rel="import" href="bower_components/paper-button/paper-button.html">
<link rel="import" href="bower_components/paper-input/paper-input.html">

<paper-input label="Your name here"></paper-input>
<paper-button>Say Hello</paper-button>

If you aren't using the polyfill, you can't rely on the WebComponentsReady
event. Instead,
simply place script at the end of the file (after any custom elements).
To use Polymer elements effectively, it's important to be familiar with a few of the common Polymer element APIs.
The Polymer element docs list element properties, but not element attributes. Unless otherwise noted, every property on a Polymer element has a corresponding attribute. Use the attribute name when configuring a property from markup, or when creating a Polymer data binding to a property.
When mapping attribute names to property names:
Attribute names are converted to lowercase property names. For example,
the attribute firstName
maps to the property firstname
.
Attribute names with dashes are converted to camelCase property names
by capitalizing the character following each dash, then removing the dashes.
For example, the attribute first-name
maps to the property firstName
.
HTML attributes are string values, but sometimes you need to pass more complicated values into a custom element, such as objects or arrays. Ultimately, it's up to the element author to decide how to decode values passed in as attributes, but many Polymer elements understand attribute values that are a JSON-serialized object or array. For example:
<roster-list persons='[{"name": "John"}, {"name": "Bob"}]'></roster-list>
For Polymer elements, you can find the expected type for each attribute listed in the API docs. If you pass the wrong type, it may be decoded incorrectly.
The same mappings happen in reverse when converting property names to attribute
names (for example, if a property is defined using reflectToAttribute: true
.)
Polymer elements also support data binding, using a format like this:
<my-element property-name="{{hostProperty}}"></my-element>
These data binding annotations are only supported in two places:
In the local DOM template of a Polymer element.
Inside an autobinding template.
For more information see Data binding.
Because not all browsers support shadow DOM natively, Polymer uses a shim called shady DOM to achieve shadow DOM's goals of composition and style encapsulation.
As a result, if you are manipulating a Polymer element, you need to use the Polymer.dom
APIs to maintain the correct DOM structure. This is particularly important when adding or removing
children from a Polymer element, for example.
For more information, see DOM API.
Many of the Polymer elements can be styled using custom CSS properties and mixins.
Property and mixin values can be specified:


A software problem has caused this software to stop unexpectedly.
We apologize for the inconvenience. An error report has been generated.
Please click Send Report to help us analyze the cause of the problem.
Learn more about how error reports are used
Error:
Providing a step-by-step description of what you were doing when the problem occurred will help us resolve the issue:


{% extends 'base.html' %} {% load static %} {% block title %} IDC | About {% endblock %} {% block description %} About IDC {% endblock %} {% block page_name %}about{% endblock %} {% block page_header %}
NCI Imaging Data Commons (IDC) is a cloud-based repository of publicly available cancer imaging data co-located with the analysis and exploration tools and resources. IDC is a node within the broader NCI Cancer Research Data Commons (CRDC) infrastructure that provides secure access to a large, comprehensive, and expanding collection of cancer research data. All data hosted by IDC will be available publicly. The current content of IDC is populated using the radiology collections from The Cancer Imaging Archive (TCIA) , as well as data collected by other major NCI initiatives, such as TCGA, CPTAC, NLST, and HTAN. IDC does not perform de-identification of images but will accept data de-identified by TCIA or other Data Coordinating Centers that are approved by NCI Security.
IDC provides access to the data standardized using the Digital Imaging and Communication in Medicine (DICOM) standard. IDC collaborates with the projects generating the data to harmonize alternative formats into DICOM representation. Its content includes not only images, but also image annotations and analysis results, and is linked using common identifiers to the other types of cancer data, such as proteomics and genomics datasets in the Cancer Research Data Commons (CRDC). Access to the data is supported using standard interfaces. Given the IDC's role as an imaging data science platform, a major focus is on establishing best practices for imaging research. In this regard, a key role of IDC is in preparing and adapting commonly used tools for image analysis to be run on cloud environments with IDC-hosted datasets. Summarized derived data from analyses previously run will be associated with imaging data on IDC for ease of use by the research community.
IDC contains various types of images and image-derived data harmonized using the DICOM standard. As of October 2022, IDC contains the following types of images:
Currently IDC will consider submissions from NCI-funded driving projects and data from special selected projects.
IDC only hosts public datasets. It does not support access limitations, such as data embargoes or sequestration.
Submitters of data to IDC must ensure that the data have been de-identified with respect to protected health information (PHI). Currently, IDC accepts data de-identified by The Cancer Imaging Archive (TCIA) . Datasets de-identified by other data coordinating centers (DCC) may be considered but in such cases further information will be required (see Google Doc form that will be used to collect information about how de-identification is done).
If you are interested in making your data available within IDC, please contact us by sending email to<EMAIL_ADDRESS>An overview of IDC is available in this open access publication. If you use IDC, please acknowledge us by citing it!
 Cancer Res. 81, 4188–4193 (2021).
http://dx.doi.org/10.1158/0008-5472.CAN-21-0950
You can also review the accompanying demonstration videos for a quick summary of some of the key features of the platform.


fullstack dev
Lorem Ipsum is simply dummy text of the printing and typesetting industry. Lorem Ipsum has been the industry's standard dummy text ever since the 1500s, when an unknown printer took a galley of type and scrambled it to make a type specimen book.
It has survived not only five centuries, but also the leap into electronic typesetting, remaining essentially unchanged. It was popularised in the 1960s with the release of Letraset sheets containing Lorem Ipsum passages, and more recently with desktop publishing software like Aldus PageMaker including versions of Lorem Ipsum.
Many desktop publishing packages and web page editors now use Lorem Ipsum as their default model text, and a search for 'lorem ipsum' will uncover many web sites still in their infancy
Fullstack Developer based out of Newcastle NSW
Contrary to popular belief, Lorem Ipsum is not simply random text.  Richard McClintock, a Latin professor at Hampden-Sydney College in Virginia, looked up one of the more obscure Latin words, consectetur, from a Lorem Ipsum passage, and going through the cites of the word in classical literature, discovered the undoubtable source.
Lorem Ipsum comes from sections 1.10.32 and 1.10.33 of "de Finibus Bonorum et Malorum" (The Extremes of Good and Evil) by Cicero, written in 45 BC. This book is a treatise on the theory of ethics, very popular during the Renaissance. The first line of Lorem Ipsum, "Lorem ipsum dolor sit amet..", comes from a line in section 1.10.32.
My Selection of my range of work


Kitura-CredentialsHTTP
A plugin for the Kitura-Credentials framework that authenticates using HTTP Basic and Digest authentication.
Summary
A plugin for Kitura-Credentials framework that authenticates using HTTP Basic and Digest authentication.
Our implementation of Digest authentication doesn’t remember nonce values it generated, and doesn’t check received request’s nonce and nc. It uses MD5 algorithm, and the quality of protection (qop) is ‘auth’.
Swift version
The latest version of Kitura-CredentialsHTTP requires Swift 4.0 or later. You can download this version of the Swift binaries by following this link. Compatibility with other Swift versions is not guaranteed.
Usage
Add dependencies
Add the Kitura-CredentialsHTTP
package to the dependencies within your application’s Package.swift
file. Substitute "x.x.x"
with the latest Kitura-CredentialsHTTP
release.
.package(url: "https://github.com/Kitura/Kitura-CredentialsHTTP.git", from: "x.x.x")
Add CredentialsHTTP
to your target’s dependencies:
.target(name: "example", dependencies: ["CredentialsHTTP"]),
Import packages
import CredentialsHTTP
Basic authentication
To create an instance of CredentialsHTTPBasic
plugin, a VerifyPassword
function and an optional realm should be passed to the constructor:
public init (verifyPassword: @escaping VerifyPassword, realm: String?=nil)
verifyPassword
is a function of type:
/// Type alias for the callback that verifies the userId and password.
/// If the authentication pair verifies, then a user profile is returned.
public typealias VerifyPassword = (userId: String, password: String, callback: @escaping (UserProfile?) -> Void) -> Void
Digest authentication
CredentialsHTTPDigest initialization is similar to CredentialsHTTPBasic. In addition, an optional opaque value can be passed to the constructor.
Example
Codable routing
First create a struct or final class that conforms to TypeSafeHTTPBasic
,
adding any instance variables, which you will initialise in verifyPassword
:
import CredentialsHTTP
public struct MyBasicAuth: TypeSafeHTTPBasic {
public let id: String
static let users = ["John" : "12345", "Mary" : "qwerasdf"]
public static func verifyPassword(username: String, password: String, callback: @escaping (MyBasicAuth?) -> Void) {
if let storedPassword = users[username], storedPassword == password {
callback(MyBasicAuth(id: username))
} else {
callback(nil)
}
}
}
Add authentication to routes by adding your TypeSafeHTTPBasic
object, as a TypeSafeMiddleware
, to your codable routes:
router.get("/protected") { (userProfile: MyBasicAuth, respondWith: (MyBasicAuth?, RequestError?) -> Void) in
print("authenticated \(userProfile.id) using \(userProfile.provider)")
respondWith(userProfile, nil)
}
Raw routing
This example shows how to use this plugin to authenticate requests with HTTP Basic authentication. HTTP Digest authentication is similar.
First create an instance of Credentials
and an instance of CredentialsHTTPBasic
plugin, supplying a verifyPassword
function:
import Credentials
import CredentialsHTTP
let credentials = Credentials()
let users = ["John" : "12345", "Mary" : "qwerasdf"]
let basicCredentials = CredentialsHTTPBasic(verifyPassword: { userId, password, callback in
if let storedPassword = users[userId], storedPassword == password {
callback(UserProfile(id: userId, displayName: userId, provider: "HTTPBasic"))
} else {
callback(nil)
}
})
Now register the plugin:
credentials.register(plugin: basicCredentials)
Connect credentials
middleware to profile requests:
router.all("/profile", middleware: credentials)
If the authentication is successful, request.userProfile
will contain user profile information:
router.get("/profile", handler:
{ request, response, next in
...
let profile = request.userProfile
let userId = profile.id
let userName = profile.displayName
...
next()
})
Troubleshooting
Seeing error ld: library not found for -lCHttpParser for architecture x86_64
on build?
To solve this, go to your Xcode build settings and add $SRCROOT/.build/debug
to the Library Search Paths for the CredentialsHTTP targets.
License
This library is licensed under Apache 2.0. Full license text is available in LICENSE.