display the waypoints
498131
def display_waypoints(wploader, map):
    ''''''
    mission_list = wploader.view_list()
    polygons = wploader.polygon_list()
    map.add_object(mp_slipmap.SlipClearLayer('Mission'))
    for i in range(len(polygons)):
        p = polygons[i]
        if len(p) > 1:
            map.add_object(mp_slipmap.SlipPolygon('mission %u' % i, p,
                                                  layer='Mission', linewidth=2, colour=(255,255,255)))
        labeled_wps = {}
        for i in range(len(mission_list)):
            next_list = mission_list[i]
            for j in range(len(next_list)):
                #label already printed for this wp?
                if (next_list[j] not in labeled_wps):
                    map.add_object(mp_slipmap.SlipLabel(
                        'miss_cmd %u/%u' % (i,j), polygons[i][j], str(next_list[j]), 'Mission', colour=(0,255,255)))  
                    labeled_wps[next_list[j]] = (i,j)
811927
function render(context, xyPoints, map, canvasFeature) {
    ctx = context;
    
    if( canvasFeature.type === 'Point' ) {
        renderPoint(xyPoints, this.size);
    } else if( canvasFeature.type === 'LineString' ) {
        renderLine(xyPoints);
    } else if( canvasFeature.type === 'Polygon' ) {
        renderPolygon(xyPoints);
    } else if( canvasFeature.type === 'MultiPolygon' ) {
        xyPoints.forEach(renderPolygon);
    }
}
605029
def display(self) -> typing.Union[None, report.Report]:
        """"""
        return (
            self._project.current_step.report
            if self._project and self._project.current_step else
            None
        )
832985
def wp_status(self):
        ''''''
        try:
            print("Have %u of %u waypoints" % (self.wploader.count()+len(self.wp_received), self.wploader.expected_count))
        except Exception:
            print("Have %u waypoints" % (self.wploader.count()+len(self.wp_received)))
29190
function Waypoint(options) {
    if (!options) {
      throw new Error('No options passed to Waypoint constructor')
    }
    if (!options.element) {
      throw new Error('No element option passed to Waypoint constructor')
    }
    if (!options.handler) {
      throw new Error('No handler option passed to Waypoint constructor')
    }

    this.key = 'waypoint-' + keyCounter
    this.options = Waypoint.Adapter.extend({}, Waypoint.defaults, options)
    this.element = this.options.element
    this.adapter = new Waypoint.Adapter(this.element)
    this.callback = options.handler
    this.axis = this.options.horizontal ? 'horizontal' : 'vertical'
    this.enabled = this.options.enabled
    this.triggerPoint = null
    this.group = Waypoint.Group.findOrCreate({
      name: this.options.group,
      axis: this.axis
    })
    this.context = Waypoint.Context.findOrCreateByElement(this.options.context)

    if (Waypoint.offsetAliases[this.options.offset]) {
      this.options.offset = Waypoint.offsetAliases[this.options.offset]
    }
    this.group.add(this)
    this.context.add(this)
    allWaypoints[this.key] = this
    keyCounter += 1
  }
429836
def to_s
      result = "Waypoint \n"
      result << "\tName: #{name}\n"
      result << "\tLatitude: #{lat} \n"
      result << "\tLongitude: #{lon} \n"
      result << "\tElevation: #{elevation}\n "
      result << "\tTime: #{time}\n"
      SUB_ELEMENTS.each do |sub_element_attribute|
        val = send(sub_element_attribute)
        result << "\t#{sub_element_attribute}: #{val}\n" unless val.nil?
      end
      result
    end
497259
def show(self):
        """"""

        # prevent the following error:
        # '_tkinter.TclError: no display name and no $DISPLAY environment
        #    variable'
        # import matplotlib
        # matplotlib.use('GTK3Agg', warn=False)

        import matplotlib.pyplot as plt

        pointlist = self.get_pointlist()
        if 'pen_down' in pointlist[0][0]:
            assert len(pointlist) > 1, \
                "Lenght of pointlist was %i. Got: %s" % (len(pointlist),
                                                         pointlist)
            # Create a new pointlist that models pen-down strokes and pen
            # up strokes
            new_pointlist = []
            last_pendown_state = None
            stroke = []
            for point in pointlist[0]:
                if last_pendown_state is None:
                    last_pendown_state = point['pen_down']
                if point['pen_down'] != last_pendown_state:
                    new_pointlist.append(stroke)
                    last_pendown_state = point['pen_down']
                    stroke = []
                else:
                    stroke.append(point)
            new_pointlist.append(stroke)  # add the last stroke
            pointlist = new_pointlist

        _, ax = plt.subplots()
        ax.set_title("Raw data id: %s, "
                     "Formula_id: %s" % (str(self.raw_data_id),
                                         str(self.formula_id)))

        colors = _get_colors(self.segmentation)
        for symbols, color in zip(self.segmentation, colors):
            for stroke_index in symbols:
                stroke = pointlist[stroke_index]
                xs, ys = [], []
                for p in stroke:
                    xs.append(p['x'])
                    ys.append(p['y'])
                if "pen_down" in stroke[0] and stroke[0]["pen_down"] is False:
                    plt.plot(xs, ys, '-x', color=color)
                else:
                    plt.plot(xs, ys, '-o', color=color)
        plt.gca().invert_yaxis()
        ax.set_aspect('equal')
        plt.show()
1275691
def display(self):
        """"""
        lg.debug('GraphicsScene is between {}s and {}s'.format(self.minimum,
                                                               self.maximum))

        x_scale = 1 / self.parent.value('overview_scale')
        lg.debug('Set scene x-scaling to {}'.format(x_scale))

        self.scale(1 / self.transform().m11(), 1)  # reset to 1
        self.scale(x_scale, 1)

        self.scene = QGraphicsScene(self.minimum, 0,
                                    self.maximum,
                                    TOTAL_HEIGHT)
        self.setScene(self.scene)

        # reset annotations
        self.idx_markers = []
        self.idx_annot = []

        self.display_current()

        for name, pos in BARS.items():
            item = QGraphicsRectItem(self.minimum, pos['pos0'],
                                     self.maximum, pos['pos1'])
            item.setToolTip(pos['tip'])
            self.scene.addItem(item)

        self.add_timestamps()
1116311
def update_waypoints(self, filename, wpnum):
        ''''''
        self.wploader.target_system = self.target_system
        self.wploader.target_component = self.target_component
        try:
            self.wploader.load(filename)
        except Exception as msg:
            print("Unable to load %s - %s" % (filename, msg))
            return
        if self.wploader.count() == 0:
            print("No waypoints found in %s" % filename)
            return
        if wpnum == -1:
            print("Loaded %u updated waypoints from %s" % (self.wploader.count(), filename))
        elif wpnum >= self.wploader.count():
            print("Invalid waypoint number %u" % wpnum)
            return
        else:
            print("Loaded updated waypoint %u from %s" % (wpnum, filename))

        self.loading_waypoints = True
        self.loading_waypoint_lasttime = time.time()
        if wpnum == -1:
            start = 0
            end = self.wploader.count()-1
        else:
            start = wpnum
            end = wpnum
        self.master.mav.mission_write_partial_list_send(self.target_system,
                                                             self.target_component,
                                                             start, end)
75562
private void readWaypoint(final Element waypoint, final List<GraphObjectMap> resultList) {

		final GraphObjectMap item = readPoint(waypoint);
		if (item != null) {

			resultList.add(item);
		}
	}
988861
def show(self):
        """"""

        if len(self.text) > self.textwidth:
            label = self.text[0:self.textwidth]
        else:
            label = self.text.rjust(self.textwidth)

        terminalSize = getTerminalSize()
        if terminalSize is None:
            terminalSize = 80
        else:
            terminalSize = terminalSize[1]

        barWidth = terminalSize - self.textwidth - 10

        if self.value is None or self.value < 0:
            pattern = self.twiddle_sequence[
                self.twiddle % len(self.twiddle_sequence)]
            self.twiddle += 1
            barSymbols = (pattern * int(math.ceil(barWidth/3.0)))[0:barWidth]
            progressFractionText = '   . %'
        else:
            progressFraction = float(self.value) / self.max

            nBlocksFrac, nBlocksInt = math.modf(
                max(0.0, min(1.0, progressFraction)) * barWidth)
            nBlocksInt = int(nBlocksInt)

            partialBlock = self.sequence[
                int(math.floor(nBlocksFrac * len(self.sequence)))]

            nBlanks = barWidth - nBlocksInt - 1
            barSymbols = (self.sequence[-1] * nBlocksInt) + partialBlock + \
                (self.sequence[0] * nBlanks)
            barSymbols = barSymbols[:barWidth]
            progressFractionText = ('%.1f%%' % (100*progressFraction)).rjust(6)

        print >>self.fid, '\r\x1B[1m' + label + '\x1B[0m [' + barSymbols + \
            ']' + progressFractionText,
        self.fid.flush()
        self.linefed = False
356311
public void showInfoWindow(){
		if (mInfoWindow == null)
			return;
		final int markerWidth = mIcon.getIntrinsicWidth();
		final int markerHeight = mIcon.getIntrinsicHeight();
		final int offsetX = (int)(markerWidth * (mIWAnchorU - mAnchorU));
		final int offsetY = (int)(markerHeight * (mIWAnchorV - mAnchorV));
		if (mBearing == 0) {
			mInfoWindow.open(this, mPosition, offsetX, offsetY);
			return;
		}
		final int centerX = 0;
		final int centerY = 0;
		final double radians = -mBearing * Math.PI / 180.;
		final double cos = Math.cos(radians);
		final double sin = Math.sin(radians);
		final int rotatedX = (int)RectL.getRotatedX(offsetX, offsetY, centerX, centerY, cos, sin);
		final int rotatedY = (int)RectL.getRotatedY(offsetX, offsetY, centerX, centerY, cos, sin);
		mInfoWindow.open(this, mPosition, rotatedX, rotatedY);
	}
451303
def show_tour(self, index):
        """"""
        self.maximize_dockwidget(restore=True)
        frames = self.tours_available[index]
        self.tour.set_tour(index, frames, self)
        self.tour.start_tour()
569327
def show(self):
        
        import matplotlib.pyplot as plt
        nx.draw(self.transforms, with_labels=True)
        plt.show()
505204
protected void view(Map values){
        for(Object key:values.keySet() ){
            assign(key.toString(), values.get(key));
        }
    }
1249771
def send_all_waypoints(self):
        ''''''
        self.master.waypoint_clear_all_send()
        if self.wploader.count() == 0:
            return
        self.loading_waypoints = True
        self.loading_waypoint_lasttime = time.time()
        self.master.waypoint_count_send(self.wploader.count())
952893
function gotNavigation(results) {
  console.log('gotNavigation', results, browser);
  var browser;
  if (results.navigator === 'treemap') {
    browser = browseTreemap;
  } else if (results.navigator === 'facet') {
    browser = browseFacet;
  } else if (results.navigator === 'cluster') {
    browser = browseCluster;
  } else if (results.navigator === 'debug') {
    browser = browseDebug;
  }
  if (browser) {
    $('.browse.sidebar').sidebar('show');
    $('#browse').html();
    browser.render('#browse', results, resultView, context);
  } else {
    $('.browse.sidebar').sidebar('hide');
  }
}