Searches for local maximas and converts into lines.

@return Found lines in the image.
509696
public FastQueue<LineParametric2D_F32> extractLines() {
		lines.reset();
		foundLines.reset();
		foundIntensity.reset();

		extractor.process(transform, null,null,null, foundLines);

		int w2 = transform.width/2;

		for( int i = 0; i < foundLines.size(); i++ ) {
			Point2D_I16 p = foundLines.get(i);

			float r = (float)(r_max*(p.x-w2)/w2);
			float c = tableTrig.c[p.y];
			float s = tableTrig.s[p.y];

			float x0 = r*c+originX;
			float y0 = r*s+originY;

			foundIntensity.push( transform.get(p.x,p.y));
			LineParametric2D_F32 l = lines.grow();
			l.p.set(x0,y0);
			l.slope.set(-s,c);

			Point2D_F64 p2 = new Point2D_F64(); // todo is this even used?!
			lineToCoordinate(l,p2);
		}

		return lines;
	}
849856
public function findOnlines(){
        $query_builder = $this->createQueryBuilder("e");
        $query_builder = $this->filterOnlines($query_builder);
        
        return $query_builder->getQuery()->getResult();
    }
769507
public String[] readLines() throws IOException {

        List<String> list = new ArrayList<String>();
        String line;
        while ((line = readLine()) != null) {
            list.add(line);
        }

        return list.toArray(new String[0]);
    }
1097154
public synchronized String getRecentLines() {
        StringBuilder sb = new StringBuilder();
        for (String line : ringBuffer) {
            if (sb.length() > 0) {
                sb.append('\n');
            }
            sb.append(line);
        }
        return sb.toString();
    }
1095418
@NonNull
  public List<LatLng> getLatLngs() {
    LineString lineString = (LineString) geometry;
    List<LatLng> latLngs = new ArrayList<>();
    for (Point point: lineString.coordinates()) {
      latLngs.add(new LatLng(point.latitude(), point.longitude()));
    }
    return latLngs;
  }
1171821
public String getCurrentLine() {
		if (!isCurrentLine()) {
			return null;
		}
		if (isTag(currentLine))
			return FlatFileUtils.trimRight(currentLine,
					getTagWidth(currentLine));
		else
			return currentLine.trim();
	}
726942
public String getNextLine() {
		if (!isNextLine()) {
			return null;
		}
		if (isTag(nextLine))
			return FlatFileUtils.trimRight(nextLine,
					getTagWidth(nextLine));
		else
			return nextLine.trim();
	}
1293399
public static long[] getMaxShape(INDArray...inputs) {
        if(inputs == null)
            return null;
        else if(inputs.length < 2)
            return inputs[0].shape();
        else {
            long[] currMax = inputs[0].shape();
            for(int i = 1; i <  inputs.length; i++) {
                if(inputs[i] == null) {
                    continue;
                }
                if(ArrayUtil.prod(currMax) < inputs[i].length()) {
                    currMax = inputs[i].shape();
                }
            }

            return currMax;
        }
    }
847407
protected function drawLines()
    {
        for ($line = 0; $line < $this->num_lines; ++ $line) {
            $x = $this->image_width * (1 + $line) / ($this->num_lines + 1);
            $x += (0.5 - $this->frand()) * $this->image_width / $this->num_lines;
            $y = mt_rand($this->image_height * 0.1, $this->image_height * 0.9);

            $theta = ($this->frand() - 0.5) * M_PI * 0.33;
            $w = $this->image_width;
            $len = mt_rand($w * 0.4, $w * 0.7);
            $lwid = mt_rand(0, 2);

            $k = $this->frand() * 0.6 + 0.2;
            $k = $k * $k * 0.5;
            $phi = $this->frand() * 6.28;
            $step = 0.5;
            $dx = $step * cos($theta);
            $dy = $step * sin($theta);
            $n = $len / $step;
            $amp = 1.5 * $this->frand() / ($k + 5.0 / $len);
            $x0 = $x - 0.5 * $len * cos($theta);
            $y0 = $y - 0.5 * $len * sin($theta);

            $ldx = round(- $dy * $lwid);
            $ldy = round($dx * $lwid);

            for ($i = 0; $i < $n; ++ $i) {
                $x = $x0 + $i * $dx + $amp * $dy * sin($k * $i * $step + $phi);
                $y = $y0 + $i * $dy - $amp * $dx * sin($k * $i * $step + $phi);
                imagefilledrectangle($this->im, $x, $y, $x + $lwid, $y + $lwid, $this->gdlinecolor);
            }
        }
    }
372501
public List<LineString> lineStrings() {
    List<List<Point>> coordinates = coordinates();
    List<LineString> lineStrings = new ArrayList<>(coordinates.size());
    for (List<Point> points : coordinates) {
      lineStrings.add(LineString.fromLngLats(points));
    }
    return lineStrings;
  }
742079
public static List<LineParametric2D_F32>
	pruneSimilarLines( List<LineParametric2D_F32> lines ,
					   float intensity[] ,
					   float toleranceAngle ,
					   float toleranceDist ,
					   int imgWidth ,
					   int imgHeight )
	{

		int indexSort[] = new int[ intensity.length ];
		QuickSort_F32 sort = new QuickSort_F32();
		sort.sort(intensity,0, lines.size(), indexSort);

		float theta[] = new float[ lines.size() ];
		List<LineSegment2D_F32> segments = new ArrayList<>(lines.size());

		for( int i = 0; i < lines.size(); i++ ) {
			LineParametric2D_F32 l = lines.get(i);
			theta[i] = UtilAngle.atanSafe(l.getSlopeY(),l.getSlopeX());
			segments.add( convert(l,imgWidth,imgHeight));
		}

		for( int i = segments.size()-1; i >= 0; i-- ) {
			LineSegment2D_F32 a = segments.get(indexSort[i]);
			if( a == null ) continue;

			for( int j = i-1; j >= 0; j-- ) {
				LineSegment2D_F32 b = segments.get(indexSort[j]);

				if( b == null )
					continue;

				if( UtilAngle.distHalf(theta[indexSort[i]],theta[indexSort[j]]) > toleranceAngle )
					continue;

				Point2D_F32 p = Intersection2D_F32.intersection(a,b,null);
				if( p != null && p.x >= 0 && p.y >= 0 && p.x < imgWidth && p.y < imgHeight ) {
					segments.set(indexSort[j],null);
				} else {
					float distA = Distance2D_F32.distance(a,b.a);
					float distB = Distance2D_F32.distance(a,b.b);

					if( distA <= toleranceDist || distB < toleranceDist ) {
						segments.set(indexSort[j],null);
					}
				}
			}
		}

		List<LineParametric2D_F32> ret = new ArrayList<>();
		for( int i = 0; i < segments.size(); i++ ) {
			if( segments.get(i) != null ) {
				ret.add( lines.get(i));
			}
		}

		return ret;
	}
1190478
public FastQueue<LineParametric2D_F32> extractLines() {
		lines.reset();
		foundLines.reset();
		foundIntensity.reset();

		extractor.process(transform,null, candidates,null, foundLines);

		for( int i = 0; i < foundLines.size(); i++ ) {
			Point2D_I16 p = foundLines.get(i);

			int x0 = p.x - originX;
			int y0 = p.y - originY;

			if( Math.abs(x0) >= minDistanceFromOrigin ||
					Math.abs(y0) >= minDistanceFromOrigin ) {
				LineParametric2D_F32 l = lines.grow();
				l.p.set(p.x,p.y);
				l.slope.set(-y0,x0);
				foundIntensity.push(transform.get(p.x,p.y));
			}
		}

		return lines;
	}
232637
public com.google.api.ads.admanager.axis.v201902.LineItemDeliveryForecast[] getLineItemDeliveryForecasts() {
        return lineItemDeliveryForecasts;
    }
818824
def maximum_vline_bundle(self, x0, y0, y1):
        

        y_range = range(y1, y0 - 1, -1) if y0 < y1 else range(y1, y0 + 1)
        vlines = [[(x0, y, 1, k) for y in y_range] for k in range(self.L)]
        return list(filter(self._contains_line, vlines))
1053244
public ActiveTunnel[] getLocalForwardingTunnels() throws IOException {
		Vector<ActiveTunnel> v = new Vector<ActiveTunnel>();
		String[] localForwardings = getLocalForwardings();
		for (int i = 0; i < localForwardings.length; i++) {
			ActiveTunnel[] tmp = getLocalForwardingTunnels(localForwardings[i]);
			for (int x = 0; x < tmp.length; x++) {
				v.add(tmp[x]);
			}
		}

		return (ActiveTunnel[]) v.toArray(new ActiveTunnel[v.size()]);
	}
816142
@NonNull
  public List<List<LatLng>> getLatLngs() {
    Polygon polygon = (Polygon) geometry;
    List<List<LatLng>> latLngs = new ArrayList<>();
    List<List<Point>> coordinates = polygon.coordinates();
    if (coordinates != null) {
      for (List<Point> innerPoints : coordinates) {
        List<LatLng> innerList = new ArrayList<>();
        for (Point point : innerPoints) {
          innerList.add(new LatLng(point.latitude(), point.longitude()));
        }
        latLngs.add(innerList);
      }
    }
    return latLngs;
  }
542607
public Coordinate[] getCoordinates() {
		if (isEmpty()) {
			return null;
		}
		int len = getNumPoints();
		Coordinate[] coordinates = new Coordinate[len];
		int count;
		for (count = 0; count < exteriorRing.getNumPoints(); count++) {
			coordinates[count] = exteriorRing.getCoordinateN(count);
		}
		if (interiorRings != null) {
			for (LinearRing interiorRing : interiorRings) {
				for (int n = 0; n < interiorRing.getNumPoints(); n++) {
					coordinates[count++] = interiorRing.getCoordinateN(n);
				}
			}
		}
		return coordinates;
	}