:param list_of_points: 
    :return: list_of_points with None's removed
760955
def filter_none(list_of_points):
    
    remove_elementnone = filter(lambda p: p is not None, list_of_points)
    remove_sublistnone = filter(lambda p: not contains_none(p), remove_elementnone)
    return list(remove_sublistnone)
922533
private void zeroMeanWorldPoints(List<AssociatedPair> points) {
		center.set(0,0);
		pointsAdj.reset();
		for (int i = 0; i < points.size(); i++) {
			AssociatedPair pair = points.get(i);
			Point2D_F64 p = pair.p1;
			pointsAdj.grow().p2.set(pair.p2);
			center.x += p.x;
			center.y += p.y;
		}
		center.x /= points.size();
		center.y /= points.size();
		for (int i = 0; i < points.size(); i++) {
			Point2D_F64 p = points.get(i).p1;
			pointsAdj.get(i).p1.set( p.x - center.x, p.y - center.y);
		}
	}
900144
def removePoint(self, point, preserveCurve=False):
        
        if not isinstance(point, int):
            point = self.points.index(point)
        point = normalizers.normalizeIndex(point)
        if point >= self._len__points():
            raise ValueError("No point located at index %d." % point)
        preserveCurve = normalizers.normalizeBoolean(preserveCurve)
        self._removePoint(point, preserveCurve)
390170
public List<Point> getPoints2() {
        verifyPropertyPresence(POINTS2);
        //noinspection unchecked
        return ((List<Map<String, Object>>) getCommandResult().get(POINTS2)).stream()
                .map(ComparisonResult::mapToPoint)
                .collect(Collectors.toList());
    }
276096
def _remove_soma_initial_point(tree):
    ''''''
    if tree.points[0][COLS.TYPE] == POINT_TYPE.SOMA:
        tree.points = tree.points[1:]
1174600
def list_unspent(oa_address_list = [])
      btc_address_list = oa_address_list.map { |oa_address| oa_address_to_address(oa_address)}
      outputs = get_unspent_outputs(btc_address_list)
      result = outputs.map{|out| out.to_hash}
      result
    end
1027489
def point_source_list(self, kwargs_ps, kwargs_lens, k=None):
        
        ra_list, dec_list = self.image_position(kwargs_ps, kwargs_lens, k=k)
        amp_list = self.image_amplitude(kwargs_ps, kwargs_lens)
        ra_array, dec_array, amp_array = [], [], []
        for i, ra in enumerate(ra_list):
            for j in range(len(ra)):
                ra_array.append(ra_list[i][j])
                dec_array.append(dec_list[i][j])
                amp_array.append(amp_list[i][j])
        return ra_array, dec_array, amp_array
401029
def remove_infinite_points(self):
        
        points_of_interest = np.where(np.all(np.isfinite(self.data), axis=0))[0]
        self._data = self.data[:, points_of_interest]
865409
def points(self):
        
        vtk_data = self.GetPoints().GetData()
        arr = vtk_to_numpy(vtk_data)
        return vtki_ndarray(arr, vtk_data)
406773
def __geomToPointList(self, geom):
        
        if arcpyFound and isinstance(geom, arcpy.Multipoint):
            feature_geom = []
            fPart = []
            for part in geom:
                fPart = []
                for pnt in part:
                    fPart.append(Point(coord=[pnt.X, pnt.Y],
                          wkid=geom.spatialReference.factoryCode,
                          z=pnt.Z, m=pnt.M))
                feature_geom.append(fPart)
            return feature_geom
411730
def _rpm_request_by_name(self, point_list):
        
        points = []
        requests = []
        for each in point_list:
            str_list = []
            point = self._findPoint(each, force_read=False)
            points.append(point)

            str_list.append(" " + point.properties.type)
            str_list.append(" " + str(point.properties.address))
            str_list.append(" presentValue")
            rpm_param = "".join(str_list)
            requests.append(rpm_param)

        return (requests, points)
846252
def _get_points(self):
        
        return tuple([self._getitem__points(i)
                     for i in range(self._len__points())])
820383
private void createDetectedList(int which, List<PointIndex2D_F64> pixels) {
		detected2D3D.clear();
		List<Point2D3D> all = getControl3D(which);
		for (int i = 0; i < pixels.size(); i++) {
			PointIndex2D_F64 a = pixels.get(i);
			Point2D3D b = all.get(i);

			pixelToNorm.compute(a.x,a.y, b.observation);
			detected2D3D.add( b );
		}
	}
67337
def points_from_sql(self, db_name):
        
        points = self._read_from_sql("SELECT * FROM history;", db_name)
        return list(points.columns.values)[1:]
1117501
def cleanPolygon(elem, options):
    
    global _num_points_removed_from_polygon

    pts = parseListOfPoints(elem.getAttribute('points'))
    N = len(pts) / 2
    if N >= 2:
        (startx, starty) = pts[:2]
        (endx, endy) = pts[-2:]
        if startx == endx and starty == endy:
            del pts[-2:]
            _num_points_removed_from_polygon += 1
    elem.setAttribute('points', scourCoordinates(pts, options, True))
691654
def _buildPointList(self):
        
        try:
            self.properties.pss.value = self.properties.network.read(
                "{} device {} protocolServicesSupported".format(
                    self.properties.address, self.properties.device_id
                )
            )

        except NoResponseFromController as error:
            self._log.error("Controller not found, aborting. ({})".format(error))
            return ("Not Found", "", [], [])

        except SegmentationNotSupported as error:
            self._log.warning("Segmentation not supported")
            self.segmentation_supported = False
            self.new_state(DeviceDisconnected)

        self.properties.name = self.properties.network.read(
            "{} device {} objectName".format(
                self.properties.address, self.properties.device_id
            )
        )

        self._log.info(
            "Device {}:[{}] found... building points list".format(
                self.properties.device_id, self.properties.name
            )
        )
        try:
            self.properties.objects_list, self.points, self.trendlogs = self._discoverPoints(
                self.custom_object_list
            )
            if self.properties.pollDelay > 0:
                self.poll(delay=self.properties.pollDelay)
        except NoResponseFromController as error:
            self._log.error("Cannot retrieve object list, disconnecting...")
            self.segmentation_supported = False
            self.new_state(DeviceDisconnected)
        except IndexError as error:
            self._log.error("Device creation failed... disconnecting")
            self.new_state(DeviceDisconnected)
1373821
def mount_points(self):
        
        aliases = self.aliases
        try:
            return [e.mdir for e in mounts() if e.dev in aliases]
        except (OSError, IOError):
            return []