Render the scene and returns the rendered image.

@see #getOutput()
@return rendered image
185973
public GrayF32 render()
	{
		ImageMiscOps.fill(output,background);
		ImageMiscOps.fill(depthMap,Float.MAX_VALUE);

		for (int i = 0; i < scene.size(); i++) {
			SurfaceRect r = scene.get(i);
			r.rectInCamera();
		}

		if( BoofConcurrency.USE_CONCURRENT ) {
			renderMultiThread();
		} else {
			renderSingleThread();
		}

		return getOutput();
	}
571803
function render()
    {
        $return = $this->renderHeaders();

        $body = $this->getBody();
        if ($body instanceof iStreamable) {
            if ($body->resource()->isSeekable()) $body->rewind();
            while (!$body->isEOF())
                $return .= $body->read(24400);
        } else {
            $return .= $body;
        }

        return $return;
    }
1112771
public function render()
    {
        $renderedChildren = $this->renderChildren();
        $encoding = mb_detect_encoding($renderedChildren);

        return mb_strtoupper($renderedChildren, $encoding);
    }
65903
public function renderAction()
    {   
        $filepath = $this->getRequest()->get('filepath');
        $hash = $this->getRequest()->get('hash');
        $filter = $this->getRequest()->get('filter');
        $tag = md5($hash . $filter);
        
        $response = new Response();
        $response->setPublic();
        $response->setEtag($tag);
        
        if($response->isNotModified($this->getRequest())){
            return $response;
        }
        
        $imageManager = $this->container->get('thrace_media.imagemanager');
        $filterManager = $this->container->get('liip_imagine.filter.manager');

        try{
            $image = $imageManager->loadPermanentImageByName($filepath);
        } catch (FileNotFound $e){
            throw new NotFoundHttpException();
        }


        $filteredImage = $filterManager->applyFilter($image, $filter);
        
        $content = $filteredImage->get($imageManager->getExtension($filepath));
        $response->setContent($content);
        $response->headers->set('Accept-Ranges', 'bytes');
        $response->headers->set('Content-Length', mb_strlen($content));
        $response->headers->set('Content-Type', $this->getMimeType($content));
        
        return $response;
    }
1253506
@Override
    public ImageWrapper render() throws SimpleImageException {
        if (drawTextParameter == null || drawTextParameter.getTextInfo() == null
            || drawTextParameter.getTextInfo().size() == 0) {
            if (imgWrapper == null) {
                return imageRender.render();
            }

            return imgWrapper;
        }

        if (imgWrapper == null) {
            imgWrapper = imageRender.render();
        }

        for (int i = 0; i < imgWrapper.getNumOfImages(); i++) {
            BufferedImage bi = imgWrapper.getAsBufferedImage(i);
            ImageDrawHelper.drawText(bi, this.drawTextParameter);
            imgWrapper.setImage(i, bi);
        }

        return imgWrapper;
    }
1145388
public function render()
    {
        if ($this->icon instanceof Icon && $this->hasTextContent()) {
            $this->attributes->addAttributeClass('btn-icon');
        }

        $output[] = $this->open();

        if ($this->hasTextContent()) {
            $output[] = implode('', $this->textContent->getArrayCopy());
        }

        if ($this->hasChildNodes()) {
            $output[] = implode(PHP_EOL, $this->childNodes->getArrayCopy());
        }

        if ($this->icon instanceof Icon) {
            $output[] = $this->icon;
        }

        $output[] = $this->close();

        return implode(PHP_EOL, $output);
    }
727977
def render_scene(self):
        ""
        self.init_gl() # should be a no-op after the first frame is rendered
        glfw.make_context_current(self.window)
        self.renderer.render_scene()
        # Done rendering
        # glfw.swap_buffers(self.window) # avoid double buffering to avoid stalling
        glFlush() # single buffering
        glfw.poll_events()
650157
public function render()
    {
        $this->setupDefaultOptions();

        if (!empty($this->value)) {
            $this->attribute('data-initial-preview', $this->preview());
            $this->attribute('data-initial-caption', $this->initialCaption($this->value));

            $this->setupPreviewOptions();
        }

        $this->options(['overwriteInitial' => true]);

        $options = json_encode($this->options);

        $this->script = <<<EOT

$("input{$this->getElementClassSelector()}").fileinput({$options});

EOT;

        return parent::render();
    }
694169
public function render()
    {
        if (!$this->checkAnsiAwareSystem()) {
            return $this->str;
        }

        if ($this->has_tags) {
            return $this->tag_format->parse($this->str);
        } elseif (!empty($this->str)) {
            $this->output->useEffect($this->format);
            return $this->output->build();
        }

        return $this->str;
    }
475267
protected void render(FacesContext context) throws IOException {

		String src = (String) getAttributes().get("src");
		boolean base64 = Boolean.parseBoolean((String) getAttributes().get("src"));
		String imagePath = getImageUrl(context, src, base64);
		ResponseWriter writer = context.getResponseWriter();
		writer.write(imagePath);
	}
1049190
public function render(){
        
        $rendered_image = '';
        
        if( file_exists( $this->script_path ) ) 
        {
            ob_start();
            include( $this->script_path );
            $rendered_image = ob_get_clean();
        } 
        else throw new TemplateNotFoundException("The following file could not be found: " . $this->script_path);
        
        return $rendered_image;
    }
1115983
@Override
    protected void renderTagEnd() {
        try {
            if (StringUtils.isNotEmpty(this.output)) {
                this.output = toString(this.escape
                        ? escape(this.output)
                        : this.output);
                JspWriter writer = this.pageContext.getOut();
                boolean renderTag = renderTag()
                        && (StringUtils.isNotBlank(this.tagName) || StringUtils.isNotBlank(getClasses()));
                if (renderTag) {
                    super.renderTagStart();
                }
                writer.write(this.output);
                if (renderTag) {
                    super.renderTagEnd();
                }
            }
        } catch (IOException ioex) {
            LOG.error(ioex.getMessage(), ioex);
        }
    }
1078443
public static function render() {
        self::newRow();
        ob_start();
        ?>

        <table <?php echo (!empty(self::$table_attributes)) ? self::parseAttributes(self::$table_attributes) : ""; ?>>
            <?php
            if (!empty(self::$headers)) {
                ?>

                <thead>
                    <tr>
                        <?php
                        foreach (self::$headers as $header) {
                            ?>

                            <th <?php echo self::parseAttributes($header[1]); ?>><?php echo $header[0] ?></th>
                            <?php
                        }
                        ?>

                    </tr>
                </thead>
                <?php
            }
            if (!empty(self::$rows)) {
                ?>

                <tbody>
                    <?php
                    foreach (self::$rows as $rowData) {
                        if (count($rowData) > 1) {
                            ?>

                            <tr <?php echo self::parseAttributes($rowData[0]); ?>>
                                <?php
                                foreach ($rowData[1] as $row) {
                                    ?>
                                    <td <?php echo self::parseAttributes($row[1]); ?>><?php echo $row[0] ?></td>
                                    <?php
                                }
                                ?>

                            </tr>
                            <?php
                        }
                    }
                    ?>

                </tbody>
                <?php
            }
            if (!empty(self::$footers)) {
                ?>

                <tfoot>
                    <tr>
                        <?php
                        foreach (self::$footers as $footer) {
                            ?>

                            <th <?php echo self::parseAttributes($footer[1]); ?>><?php echo $footer[0] ?></th>
                            <?php
                        }
                        ?>

                    </tr>
                </tfoot>
            <?php }
            ?>
        </table>
        <?php
        return ob_get_clean();
    }
1177993
public function render()
    {
        $output[] = $this->open();

        if ($this->hasIcon()) {
            $output[] = $this->icon;
        }

        if ($this->hasTextContent()) {
            $output[] = PHP_EOL . implode('', $this->textContent->getArrayCopy()) . PHP_EOL;
        }

        if ($this->hasChildNodes()) {
            if ( ! $this->hasTextContent()) {
                $output[] = PHP_EOL;
            }

            foreach ($this->childNodes as $childNode) {
                $output[] = $childNode . PHP_EOL;
            }
        }

        $output[] = $this->close();

        return implode('', $output);
    }
1110415
private function _render(){
        $textColor = new CINColor($this->foregroundColor);
        $backgroudColor = new CINColor($this->backgroundColor);
        
        /* Here is the list of the arguments
        1 - Filename (empty : display on screen)
        2 - Background color */
        $drawing = new CINDrawing($this->filename, $backgroudColor);
        
        $drawException = null;
        
        if(isset($this->format) and !in_array(strtoupper($this->format), $this->allowedFormats)){
            $drawException = $this->format .' format is not allowed.';
        }
        
        if(!isset($this->barcodeType)){
            $drawException = 'Unable to generate barcode for unknown type';
        }else{
            try{
                if(!($code = $this->_getCode())){
                    $drawException = 'Unable to generate barcode';
                }
            } catch(\Exception $e){
                $drawException = $e->getMessage();
            }
        }

        ob_start();
        if($drawException) {
            $exception = new \Exception($drawException);
            $drawing->drawException($exception);
        } else {
            $drawing->setBarcode($code);
            $drawing->draw();
        }
        $drawing->finish($this->_getFormat());
        $barcodeImg = ob_get_clean();
        $barcodeImg = base64_encode($barcodeImg);
        return $barcodeImg;
    }
546792
public function render()
    {
        $this->engine->parse($this->file);
        $output = $this->engine->process($this->data);
        return $output;
    }
846044
public function render()
	{
		$path = $this->template;
		if (array_key_exists($path, ViewModel::$availableTemplates)) {
			$path = 'src/' . ViewModel::$availableTemplates[$this->template];
		}
		if (file_exists($path)) {
			ob_start();
			include($path);
			$output = ob_get_contents();
			ob_end_clean();
			return $output;
		} else {
			throw new \Exception("The requested template (" . $path . ") not found!");
		}
	}