text:
<?php

namespace Lists\ProjectBundle\Entity;

use Doctrine\ORM\Mapping as ORM;

/**
 * ProjectStateTendereTenderParticipant
 */
class ProjectStateTenderParticipant
{
    public function __construct()
    {
        $this->setDatetimeCreate(new \DateTime());
    }
    /**
     * @var integer
     */
    private $id;

    /**
     * @var string
     */
    private $summa;

    /**
     * @var boolean
     */
    private $isWinner;

    /**
     * @var string
     */
    private $reason;

    /**
     * @var \DateTime
     */
    private $datetimeCreate;

    /**
     * @var \DateTime
     */
    private $datetimeDeleted;

    /**
     * @var \Lists\OrganizationBundle\Entity\Organization
     */
    private $participant;

    /**
     * @var \Lists\ProjectBundle\Entity\ProjectStateTender
     */
    private $projectStateTender;

    /**
     * Get id
     *
     * @return integer
     */
    public function getId()
    {
        return $this->id;
    }

    /**
     * Set summa
     *
     * @param string $summa
     *
     * @return ProjectStateTenderParticipant
     */
    public function setSumma($summa)
    {
        $this->summa = $summa;

        return $this;
    }

    /**
     * Get summa
     *
     * @return string
     */
    public function getSumma()
    {
        return $this->summa;
    }

    /**
     * Set isWinner
     *
     * @param boolean $isWinner
     * @return ProjectStateTenderParticipant
     */
    public function setIsWinner($isWinner)
    {
        $this->isWinner = $isWinner;

        return $this;
    }

    /**
     * Get isWinner
     *
     * @return boolean
     */
    public function getIsWinner()
    {
        return $this->isWinner;
    }

    /**
     * Set reason
     *
     * @param string $reason
     * @return ProjectStateTenderParticipant
     */
    public function setReason($reason)
    {
        $this->reason = $reason;

        return $this;
    }

    /**
     * Get reason
     *
     * @return string
     */
    public function getReason()
    {
        return $this->reason;
    }

    /**
     * Set datetimeCreate
     *
     * @param \DateTime $datetimeCreate
     * @return ProjectStateTenderParticipant
     */
    public function setDatetimeCreate($datetimeCreate)
    {
        $this->datetimeCreate = $datetimeCreate;

        return $this;
    }

    /**
     * Get datetimeCreate
     *
     * @return \DateTime
     */
    public function getDatetimeCreate()
    {
        return $this->datetimeCreate;
    }

    /**
     * Set datetimeDeleted
     *
     * @param \DateTime $datetimeDeleted
     * @return ProjectStateTenderParticipant
     */
    public function setDatetimeDeleted($datetimeDeleted)
    {
        $this->datetimeDeleted = $datetimeDeleted;

        return $this;
    }

    /**
     * Get datetimeDeleted
     *
     * @return \DateTime
     */
    public function getDatetimeDeleted()
    {
        return $this->datetimeDeleted;
    }

    /**
     * Set participant
     *
     * @param \Lists\OrganizationBundle\Entity\Organization $participant
     * @return ProjectStateTenderParticipant
     */
    public function setParticipant(\Lists\OrganizationBundle\Entity\Organization $participant = null)
    {
        $this->participant = $participant;

        return $this;
    }

    /**
     * Get participant
     *
     * @return \Lists\OrganizationBundle\Entity\Organization
     */
    public function getParticipant()
    {
        return $this->participant;
    }

    /**
     * Set ProjectStateTender
     *
     * @param \Lists\ProjectBundle\Entity\ProjectStateTender $projectStateTender
     * @return ProjectStateTenderParticipant
     */
    public function setProjectStateTender(\Lists\ProjectBundle\Entity\ProjectStateTender $projectStateTender = null)
    {
        $this->projectStateTender = $projectStateTender;

        return $this;
    }

    /**
     * Get projectStateTender
     *
     * @return \Lists\ProjectBundle\Entity\ProjectStateTender
     */
    public function getProjectStateTender()
    {
        return $this->projectStateTender;
    }
    /**
     * getParticipations
     *
     * @return mixed[]
     */
    public static function getChoiceList ()
    {
        return array (
            true => 'Yes',
            false => 'No'
        );
    }
}


text:
Go Authentication Handling For Sizema/Moni-Tron

[![GoDoc](https://godoc.org/github.com/samuelrayment/authatron?status.svg)](https://godoc.org/github.com/samuelrayment/authatron)

redpajama_set_name: RedPajamaGithub


text:
actions :create, :delete

default_action :create

attribute :display_name,  :kind_of => String, :default => nil
attribute :groups,  :kind_of => Array, :default => nil
attribute :assign_where,  :kind_of => Array, :default => nil
attribute :ignore_where,  :kind_of => Array, :default => nil


text:
namespace content {

class WebContents;

class DevToolsFrontendHostImpl : public DevToolsFrontendHost,
                                 public blink::mojom::DevToolsFrontendHost {
 public:
  DevToolsFrontendHostImpl(
      RenderFrameHost* frame_host,
      const HandleMessageCallback& handle_message_callback);
  ~DevToolsFrontendHostImpl() override;

  void BadMessageRecieved() override;

 private:
  // blink::mojom::DevToolsFrontendHost implementation.
  void DispatchEmbedderMessage(const std::string& message) override;

  WebContents* web_contents_;
  HandleMessageCallback handle_message_callback_;
  mojo::AssociatedReceiver<blink::mojom::DevToolsFrontendHost> receiver_{this};

  DISALLOW_COPY_AND_ASSIGN(DevToolsFrontendHostImpl);
};

}  // namespace content

#endif  // CONTENT_BROWSER_DEVTOOLS_DEVTOOLS_FRONTEND_HOST_IMPL_H_


text:
using arrow::pass::Build;

auto Build::handle_expression_statement(ptr<ast::ExpressionStatement> x) -> ptr<ir::Value> {
  // Build the expression
  auto ref = run(x->expression);
  if (!ref) return nullptr;

  return ref;
}


text:
#pragma once

#include <functional>
#include <unordered_map>
#include <vector>

#include <infrastructure/meshes.h>

#include "aas_math.h"

namespace aas {

	typedef void* AasMaterial;

	class Skeleton;
	class Mesh;
	struct ActiveModel;
	class AnimatedModel;
	struct SkeletonCacheEntry;

	using AasHandle = uint32_t;

	struct AasAnimParams {
		uint32_t flags;
		uint32_t unknown;
		uint64_t locX;
		uint64_t locY;
		float offsetX;
		float offsetY;
		float offsetZ;
		float rotation;
		float scale;
		float rotationRoll;
		float rotationPitch;
		float rotationYaw;
		AasHandle parentAnim;
		char attachedBoneName[48];
	};

	struct AnimEvents {
		/**
		 * Indicates the animation has ended.
		 */
		bool end : 1;
		/**
		 * Indicates that the frame on which an action should connect (weapon swings, etc.)
		 * has occurred.
		 */
		bool action : 1;
		AnimEvents() : end(false), action(false) {}
	};

	class IMaterialResolver {
	public:
		virtual AasMaterial Acquire(std::string_view materialName, std::string_view context) = 0;
		virtual void Release(AasMaterial material, std::string_view context) = 0;
		virtual ~IMaterialResolver() = default;

		virtual bool IsMaterialPlaceholder(AasMaterial material) const = 0;
		virtual gfx::MaterialPlaceholderSlot GetMaterialPlaceholderSlot(AasMaterial material) const = 0;
	};

	class AasSystem {
	public:
		AasSystem(std::function<std::string(int)> getSkeletonFilename,
			std::function<std::string(int)> getMeshFilename,
			std::function<void(const std::string&)> runScript,
			std::unique_ptr<IMaterialResolver> materialResolver);
		~AasSystem();

		AasHandle CreateModelFromIds(
			int meshId,
			int skeletonId,
			gfx::EncodedAnimId idleAnimId,
			const AasAnimParams& params
		);

		AasHandle CreateModel(
			std::string_view meshFilename,
			std::string_view skeletonFilename,
			gfx::EncodedAnimId idleAnimId,
			const AasAnimParams& params
		);

		bool SetAnimById(AasHandle handle, gfx::EncodedAnimId animId);
		bool HasAnimId(AasHandle handle, gfx::EncodedAnimId animId) const;
		gfx::EncodedAnimId GetAnimId(AasHandle handle) const;

		AnimEvents Advance(AasHandle handle,
			float deltaTimeInSecs,
			float deltaDistance,
			float deltaRotation,
			const AasAnimParams &params);

		void UpdateWorldMatrix(AasHandle handle, const AasAnimParams& params, bool forParticles = false);

		std::unique_ptr<gfx::Submesh> GetSubmesh(AasHandle handle,
			const AasAnimParams& params,
			int submeshIdx);

		std::unique_ptr<gfx::Submesh> GetSubmeshForParticles(AasHandle handle,
			const AasAnimParams& params,
			int submeshIdx);

		void ReleaseAllModels();
		void ReleaseModel(AasHandle handle);

		bool IsValidHandle(AasHandle handle) const;
		AnimatedModel &GetAnimatedModel(AasHandle handle) const;

		void AddAdditionalMesh(AasHandle handle, std::string_view filename);
		void ClearAddmeshes(AasHandle handle);

		bool GetBoneWorldMatrixByName(AasHandle handle,
			const AasAnimParams &params,
			std::string_view boneName,
			DX::XMFLOAT4X4 *worldMatrixOut);

		bool GetBoneWorldMatrixByNameForChild(AasHandle parentHandle,
			AasHandle handle,
			const AasAnimParams &params,
			std::string_view boneName,
			DX::XMFLOAT4X4 *worldMatrixOut);

		void SetTime(AasHandle handle, float time, const AasAnimParams &params);

		void ReplaceMaterial(AasHandle handle, gfx::MaterialPlaceholderSlot slot, AasMaterial material);

	private:

		static constexpr size_t MaxAnims = 5000;

		std::function<std::string(int)> getSkeletonFilename_;
		std::function<std::string(int)> getMeshFilename_;
		std::unique_ptr<IMaterialResolver> materialResolver_;

		std::unordered_map<std::string, SkeletonCacheEntry> skeletonCache_;

		std::unique_ptr<ActiveModel> activeModels_[MaxAnims];

		float worldScaleX_ = 28.284271f;
		float worldScaleY_ = 28.284271f;

		std::unique_ptr<class EventHandler> eventHandler_;

		ActiveModel &GetActiveModel(AasHandle handle) const;
		AasHandle FindFreeHandle() const;

		Matrix3x4 GetWorldMatrix(const AasAnimParams &params) const;
		Matrix3x4 GetWorldMatrixForParticles(const AasAnimParams &params) const;

	};

}


text:
(function () {
  'use strict';

  var logViewModule = angular.module('logViewModule', ['ui.grid', 'ui.grid.autoResize', 'ui.grid.autoScroll']);
  registerModule(logViewModule);

  logViewModule.run(function(route, sideNav, toolBar, $state) {
    route.register('log', '/log', 'LogViewCtrl', 'plugin/log/static/index.html');
    sideNav.register('/log', 'Log', 'fa fa-file-text-o', 128);
    toolBar.registerButton('Log', 'fa fa-file-text-o', function(){$state.go('log')});
  });

  logViewModule.controller('LogViewCtrl', function ($scope, $timeout, uiGridConstants) {
    var filterTimeout, newDataTimeout;
    var logStream = false;

    $scope.status = 'Connecting';
    $scope.lines = 400;
    $scope.search = '';

    $scope.toggleStream = function() {
      if ($scope.status == "Disconnected") {
        $scope.updateGrid();
      } else {
        abort();
      }
    };

    $scope.updateGrid = function () {
      // Delay for 1 second before getting search results from server
      if (angular.isDefined(filterTimeout)) {
        $timeout.cancel(filterTimeout);
      }
      filterTimeout = $timeout(function () {
        getLogData()
      }, 1000);
    };

    var abort = function () {
      if (angular.isDefined(filterTimeout)) {
        $timeout.cancel(filterTimeout);
      }
      if (typeof logStream !== 'undefined' && logStream) {
        logStream.abort();
        logStream = false;
        $scope.status = "Disconnected";
      }
    };

    var getLogData = function () {
      // Disconnect existing log streams
      abort();

      $scope.status = "Connecting";
      $scope.gridOptions.data = [];

      var queryParams = '?lines=' + $scope.lines;
      if ($scope.search) {
        queryParams = queryParams + '&search=' + $scope.search;
      }

      logStream = oboe({url: '/api/server/log/' + queryParams})
        .start(function () {
          $scope.$applyAsync(function () {
            $scope.status = "Streaming";
          });
        })
        .node('{message}', function(node) {
          $scope.$applyAsync(function () {
            $scope.gridOptions.data.push(node);
          });
        })
        .fail(function (test){
          $scope.$applyAsync(function () {
            $scope.status = "Disconnected";
          });
        })
    };

    var rowTemplate = '

' +
      '

';

    $scope.gridOptions = {
      data: [],
      enableSorting: true,
      rowHeight: 20,
      columnDefs: [
        {field: 'timestamp', name: 'Time', cellFilter: 'date', enableSorting: true, width: 120},
        {field: 'log_level', name: 'Level', enableSorting: false, width: 65},
        {field: 'plugin', name: 'Plugin', enableSorting: false, width: 80, cellTooltip: true},
        {field: 'task', name: 'Task', enableSorting: false, width: 65, cellTooltip: true},
        {field: 'message', name: 'Message', enableSorting: false, minWidth: 400, cellTooltip: true}
      ],
      rowTemplate: rowTemplate,
      onRegisterApi: function (gridApi) {
        $scope.gridApi = gridApi;
        getLogData();
      }
    };

    // Cancel timer and stop the stream when navigating away
    $scope.$on("$destroy", function () {
      abort();
    });
  });

})();


text:
import direction_model
from ioUtils import *
import math
import lossFunction
import tensorflow as tf
import numpy as np
import sys
import os
import scipy.io as sio
import re
import time

VGG_MEAN = [103.939, 116.779, 123.68]

tf.set_random_seed(0)

def initialize_model(outputChannels, wd=None, modelWeightPaths=None):
    fuseChannels=256
    params = {"direction/conv1_1": {"name": "direction/conv1_1", "shape": [3,3,4,64], "std": None, "act": "relu"},
            "direction/conv1_2": {"name": "direction/conv1_2", "shape": [3,3,64,64], "std": None, "act": "relu"},
            "direction/conv2_1": {"name": "direction/conv2_1", "shape": [3,3,64,128], "std": None, "act": "relu"},
            "direction/conv2_2": {"name": "direction/conv2_2", "shape": [3,3,128,128], "std": None, "act": "relu"},
            "direction/conv3_1": {"name": "direction/conv3_1", "shape": [3,3,128,256], "std": None, "act": "relu"},
            "direction/conv3_2": {"name": "direction/conv3_2", "shape": [3,3,256,256], "std": None, "act": "relu"},
            "direction/conv3_3": {"name": "direction/conv3_3", "shape": [3,3,256,256], "std": None, "act": "relu"},
            "direction/conv4_1": {"name": "direction/conv4_1", "shape": [3,3,256,512], "std": None, "act": "relu"},
            "direction/conv4_2": {"name": "direction/conv4_2", "shape": [3,3,512,512], "std": None, "act": "relu"},
            "direction/conv4_3": {"name": "direction/conv4_3", "shape": [3,3,512,512], "std": None, "act": "relu"},
            "direction/conv5_1": {"name": "direction/conv5_1", "shape": [3,3,512,512], "std": None, "act": "relu"},
            "direction/conv5_2": {"name": "direction/conv5_2", "shape": [3,3,512,512], "std": None, "act": "relu"},
            "direction/conv5_3": {"name": "direction/conv5_3", "shape": [3,3,512,512], "std": None, "act": "relu"},
            "direction/fcn5_1": {"name": "direction/fcn5_1", "shape": [5,5,512,512], "std": None, "act": "relu"},
            "direction/fcn5_2": {"name": "direction/fcn5_2", "shape": [1,1,512,512], "std": None, "act": "relu"},
            "direction/fcn5_3": {"name": "direction/fcn5_3", "shape": [1,1,512,fuseChannels], "std": 1e-2, "act": "relu"},
            "direction/upscore5_3": {"name": "direction/upscore5_3", "ksize": 8, "stride": 4, "outputChannels": fuseChannels},
            "direction/fcn4_1": {"name": "direction/fcn4_1", "shape": [5,5,512,512], "std": None, "act": "relu"},
            "direction/fcn4_2": {"name": "direction/fcn4_2", "shape": [1,1,512,512], "std": None, "act": "relu"},
            "direction/fcn4_3": {"name": "direction/fcn4_3", "shape": [1,1,512,fuseChannels], "std": 1e-3, "act": "relu"},
            "direction/upscore4_3": {"name": "direction/upscore4_3", "ksize": 4, "stride": 2, "outputChannels": fuseChannels},
            "direction/fcn3_1": {"name": "direction/fcn3_1", "shape": [5,5,256,256], "std": None, "act": "relu"},
            "direction/fcn3_2": {"name": "direction/fcn3_2", "shape": [1,1,256,256], "std": None, "act": "relu"},
            "direction/fcn3_3": {"name": "direction/fcn3_3", "shape": [1,1,256,fuseChannels], "std": 1e-4, "act": "relu"},
            "direction/fuse3_1": {"name": "direction/fuse_1", "shape": [1,1,fuseChannels*3, 512], "std": None, "act": "relu"},
            "direction/fuse3_2": {"name": "direction/fuse_2", "shape": [1,1,512,512], "std": None, "act": "relu"},
            "direction/fuse3_3": {"name": "direction/fuse_3", "shape": [1,1,512,outputChannels], "std": None, "act": "lin"},
            "direction/upscore3_1": {"name": "direction/upscore3_1", "ksize": 8, "stride": 4, "outputChannels":outputChannels}}

    return direction_model.Network(params, wd=wd, modelWeightPaths=modelWeightPaths)

def forward_model(model, feeder, outputSavePath):
    with tf.Session() as sess:
        tfBatchImages = tf.placeholder("float", shape=[None, 512, 1024, 3])
        tfBatchSS = tf.placeholder("float", shape=[None, 512, 1024])
        tfBatchSSMask = tf.placeholder("float", shape=[None, 512, 1024])

        with tf.name_scope("model_builder"):
            print "attempting to build model"
            model.build(tfBatchImages, tfBatchSS, tfBatchSSMask)
            print "built the model"
        sys.stdout.flush()

        init = tf.initialize_all_variables()
        sess.run(init)

        for i in range(int(math.floor(feeder.total_samples() / batchSize))):
            imageBatch, ssBatch, ssMaskBatch, idBatch = feeder.next_batch()

            outputBatch = sess.run(model.output, feed_dict={tfBatchImages: imageBatch, tfBatchSS: ssBatch, tfBatchSSMask: ssMaskBatch})

            for j in range(len(idBatch)):
                outputFilePath = os.path.join(outputSavePath, idBatch[j]+'.mat')
                outputFileDir = os.path.dirname(outputFilePath)

                if not os.path.exists(outputFileDir):
                    os.makedirs(outputFileDir)

                sio.savemat(outputFilePath, {"dir_map": outputBatch[j]}, do_compression=True)

                print "processed image %d out of %d"%(j+batchSize*i, feeder.total_samples())

def train_model(model, outputChannels, learningRate, trainFeeder, valFeeder, modelSavePath=None, savePrefix=None, initialIteration=1):
    with tf.Session() as sess:
        tfBatchImages = tf.placeholder("float", shape=[None, 512, 1024, 3])
        tfBatchGT = tf.placeholder("float", shape=[None, 512, 1024, 2])
        tfBatchWeight = tf.placeholder("float", shape=[None, 512, 1024])
        tfBatchSS = tf.placeholder("float", shape=[None, 512, 1024])
        tfBatchSSMask = tf.placeholder("float", shape=[None, 512, 1024])

        with tf.name_scope("model_builder"):
            print "attempting to build model"
            model.build(tfBatchImages, tfBatchSS, tfBatchSSMask)
            print "built the model"

        sys.stdout.flush()
        loss = lossFunction.angularErrorLoss(pred=model.output, gt=tfBatchGT, weight=tfBatchWeight, ss=tfBatchSS, outputChannels=outputChannels)

        angleError = lossFunction.angularErrorTotal(pred=model.output, gt=tfBatchGT, weight=tfBatchWeight, ss=tfBatchSS, outputChannels=outputChannels)
        numPredicted = lossFunction.countTotal(ss=tfBatchSS)
        numPredictedWeighted = lossFunction.countTotalWeighted(ss=tfBatchSS, weight=tfBatchWeight)
        exceed45 = lossFunction.exceedingAngleThreshold(pred=model.output, gt=tfBatchGT,
                                                        ss=tfBatchSS, threshold=45.0, outputChannels=outputChannels)
        exceed225 = lossFunction.exceedingAngleThreshold(pred=model.output, gt=tfBatchGT,
                                                        ss=tfBatchSS, threshold=22.5, outputChannels=outputChannels)

        train_op = tf.train.AdamOptimizer(learning_rate=learningRate).minimize(loss=loss)

        init = tf.initialize_all_variables()

        sess.run(init)
        iteration = initialIteration

        while iteration < 1000:
            batchLosses = []
            totalAngleError = 0
            totalExceed45 = 0
            totalExceed225 = 0
            totalPredicted = 0
            totalPredictedWeighted = 0

            for k in range(int(math.floor(valFeeder.total_samples() / batchSize))):
                imageBatch, gtBatch, weightBatch, ssBatch, ssMaskBatch, _ = valFeeder.next_batch()

                batchLoss, batchAngleError, batchPredicted, batchPredictedWeighted, batchExceed45, batchExceed225 = sess.run(
                    [loss, angleError, numPredicted, numPredictedWeighted, exceed45, exceed225],
                    feed_dict={tfBatchImages: imageBatch,
                               tfBatchGT: gtBatch,
                               tfBatchWeight: weightBatch,
                               tfBatchSS: ssBatch,
                               tfBatchSSMask: ssMaskBatch})
                # print "ran iteration"
                batchLosses.append(batchLoss)
                totalAngleError += batchAngleError
                totalPredicted += batchPredicted
                totalPredictedWeighted += batchPredictedWeighted
                totalExceed45 += batchExceed45
                totalExceed225 += batchExceed225

            if np.isnan(np.mean(batchLosses)):
                print "LOSS RETURNED NaN"
                sys.stdout.flush()
                return 1

            print "%s Itr: %d - val loss: %.3f, angle MSE: %.3f, exceed45: %.3f, exceed22.5: %.3f" % (
                time.strftime("%H:%M:%S"), iteration,
            float(np.mean(batchLosses)), totalAngleError / totalPredictedWeighted,
            totalExceed45 / totalPredicted, totalExceed225 / totalPredicted)
            sys.stdout.flush()

            if (iteration > 0 and iteration % 5 == 0) or checkSaveFlag(modelSavePath):
                modelSaver(sess, modelSavePath, savePrefix, iteration)

            for j in range(int(math.floor(trainFeeder.total_samples() / batchSize))):
                # print "running batch %d"%(j)
                # sys.stdout.flush()
                imageBatch, gtBatch, weightBatch, ssBatch, ssMaskBatch, _ = trainFeeder.next_batch()
                sess.run(train_op, feed_dict={tfBatchImages: imageBatch,
                                              tfBatchGT: gtBatch,
                                              tfBatchWeight: weightBatch,
                                              tfBatchSS: ssBatch,
                                              tfBatchSSMask: ssMaskBatch})
            iteration += 1

def modelSaver(sess, modelSavePath, savePrefix, iteration, maxToKeep=5):
    allWeights = {}
    for name in [n.name for n in tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES)]:
        param = sess.run(name)
        nameParts = re.split('[:/]', name)
        saveName = nameParts[-4]+'/'+nameParts[-3]+'/'+nameParts[-2]
        allWeights[saveName] = param

    weightsFileName = os.path.join(modelSavePath, savePrefix+'_%03d'%iteration)

    sio.savemat(weightsFileName, allWeights)

def checkSaveFlag(modelSavePath):
    flagPath = os.path.join(modelSavePath, 'saveme.flag')

    if os.path.exists(flagPath):
        return True
    else:
        return False

if __name__ == "__main__":
    outputChannels = 2
    classType = 'unified_CR'
    indices = [0,1,2,3,4,5,6,7]
    # 0=car, 1=person, 2=rider, 3=motorcycle, 4=bicycle, 5=truck, 6=bus, 7=train
    savePrefix = "direction_" + classType + "_unified_CR_pretrain"
    train = True

    if train:
        batchSize = 4
        learningRate = 1e-5
        # learningRateActual = 1e-7
        wd = 1e-5

        modelWeightPaths = ["./cityscapes/models/direction/VGG16init_conv1_ch4.mat"]
        initialIteration = 1

        model = initialize_model(outputChannels=outputChannels, wd=wd, modelWeightPaths=modelWeightPaths)

        trainFeeder = Batch_Feeder(dataset="cityscapes", indices=indices, train=train, batchSize=batchSize,
                                   padWidth=None, padHeight=None, flip=True, keepEmpty=False)
        trainFeeder.set_paths(idList=read_ids('./cityscapes/splits/trainlist.txt'),
                         imageDir="./cityscapes/inputImages/train",
                         gtDir="./cityscapes/unified/iGTFine/train",
                         ssDir="./cityscapes/unified/ssMaskFineGT/train")

        valFeeder = Batch_Feeder(dataset="cityscapes", indices=indices, train=train, batchSize=batchSize,
                                 padWidth=None, padHeight=None)

        valFeeder.set_paths(idList=read_ids('./cityscapes/splits/vallist.txt'),
                         imageDir="./cityscapes/inputImages/val",
                         gtDir="./cityscapes/unified/iGTFine/val",
                         ssDir="./cityscapes/unified/ssMaskFineGT/val")

        train_model(model=model, outputChannels=outputChannels,
                    learningRate=learningRate,
                    trainFeeder=trainFeeder, valFeeder=valFeeder,
                    modelSavePath="./cityscapes/models/direction", savePrefix=savePrefix,
                    initialIteration=initialIteration)
    else:
        batchSize = 5
        modelWeightPaths = ["./cityscapes/models/direction/direction3_unified_ss_wide_pretrain_VGGFIX_020.mat"]

        model = initialize_model(outputChannels=outputChannels, wd=0, modelWeightPaths=modelWeightPaths)

        feeder = Batch_Feeder(dataset="cityscapes", indices=indices, train=train, batchSize=batchSize, padWidth=None, padHeight=None)
        feeder.set_paths(idList=read_ids("./cityscapes/splits/vallist.txt"),
                         imageDir="./cityscapes/inputImages/val",
                         ssDir="./cityscapes/unified/ssMaskFineGT/val")

        forward_model(model, feeder=feeder,
                      outputSavePath="./training/output/direction_ss")


text:
/* $Id$ */

package org.apache.fop.render.pdf;
import java.awt.Color;
import java.awt.color.ColorSpace;
import java.awt.color.ICC_ColorSpace;
import java.awt.color.ICC_Profile;
import java.awt.image.ColorModel;
import java.awt.image.IndexColorModel;
import java.awt.image.RenderedImage;
import java.io.IOException;
import java.io.OutputStream;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

import org.apache.xmlgraphics.image.loader.impl.ImageRendered;
import org.apache.xmlgraphics.ps.ImageEncodingHelper;

import org.apache.fop.pdf.AlphaRasterImage;
import org.apache.fop.pdf.PDFColor;
import org.apache.fop.pdf.PDFDeviceColorSpace;
import org.apache.fop.pdf.PDFDictionary;
import org.apache.fop.pdf.PDFDocument;
import org.apache.fop.pdf.PDFFilter;
import org.apache.fop.pdf.PDFFilterList;
import org.apache.fop.pdf.PDFReference;

/**
 * PDFImage implementation for the PDF renderer which handles RenderedImages.
 */
public class ImageRenderedAdapter extends AbstractImageAdapter {

    /** logging instance */
    private static Log log = LogFactory.getLog(ImageRenderedAdapter.class);

    private ImageEncodingHelper encodingHelper;

    private PDFFilter pdfFilter;
    private String maskRef;
    private PDFReference softMask;

    /**
     * Creates a new PDFImage from an Image instance.
     * @param image the image
     * @param key XObject key
     */
    public ImageRenderedAdapter(ImageRendered image, String key) {
        super(image, key);
        this.encodingHelper = new ImageEncodingHelper(image.getRenderedImage());
    }

    /**
     * Returns the ImageRendered instance for this adapter.
     * @return the ImageRendered instance
     */
    public ImageRendered getImage() {
        return ((ImageRendered)this.image);
    }

    /** {@inheritDoc} */
    @Override
    public int getWidth() {
        RenderedImage ri = getImage().getRenderedImage();
        return ri.getWidth();
    }

    /** {@inheritDoc} */
    @Override
    public int getHeight() {
        RenderedImage ri = getImage().getRenderedImage();
        return ri.getHeight();
    }

    private ColorModel getEffectiveColorModel() {
        return encodingHelper.getEncodedColorModel();
    }

    /** {@inheritDoc} */
    @Override
    protected ColorSpace getImageColorSpace() {
        return getEffectiveColorModel().getColorSpace();
    }

    /** {@inheritDoc} */
    @Override
    protected ICC_Profile getEffectiveICCProfile() {
        ColorSpace cs = getImageColorSpace();
        if (cs instanceof ICC_ColorSpace) {
            ICC_ColorSpace iccSpace = (ICC_ColorSpace)cs;
            return iccSpace.getProfile();
        } else {
            return null;
        }
    }

    /** {@inheritDoc} */
    @Override
    public void setup(PDFDocument doc) {
        RenderedImage ri = getImage().getRenderedImage();

        super.setup(doc);

        //Handle transparency mask if applicable
        ColorModel orgcm = ri.getColorModel();
        if (orgcm.hasAlpha() && orgcm.getTransparency() == ColorModel.TRANSLUCENT) {
            doc.getProfile().verifyTransparencyAllowed(image.getInfo().getOriginalURI());
            //TODO Implement code to combine image with background color if transparency is not
            //allowed (need BufferedImage support for that)

            AlphaRasterImage alphaImage = new AlphaRasterImage("Mask:" + getKey(), ri);
            this.softMask = doc.addImage(null, alphaImage).makeReference();
        }
    }

    /** {@inheritDoc} */
    public PDFDeviceColorSpace getColorSpace() {
        // DeviceGray, DeviceRGB, or DeviceCMYK
        return toPDFColorSpace(getEffectiveColorModel().getColorSpace());
    }

    /** {@inheritDoc} */
    public int getBitsPerComponent() {
        ColorModel cm = getEffectiveColorModel();
        if (cm instanceof IndexColorModel) {
            IndexColorModel icm = (IndexColorModel)cm;
            return icm.getComponentSize(0);
        } else {
            return cm.getComponentSize(0);
        }
    }

    /** {@inheritDoc} */
    @Override
    public boolean isTransparent() {
        return (getImage().getTransparentColor() != null);
    }

    /** {@inheritDoc} */
    @Override
    public PDFColor getTransparentColor() {
        ColorModel cm = getEffectiveColorModel();
        if (cm instanceof IndexColorModel) {
            IndexColorModel icm = (IndexColorModel)cm;
            if (cm.getTransparency() == IndexColorModel.TRANSLUCENT
                    || cm.getTransparency() == IndexColorModel.BITMASK) {
                int transPixel = icm.getTransparentPixel();
                if (transPixel != -1) {
                    return new PDFColor(
                            icm.getRed(transPixel),
                            icm.getGreen(transPixel),
                            icm.getBlue(transPixel));
                }
            }
        }
        Color transColor = getImage().getTransparentColor();
        if (transColor != null) {
            return new PDFColor(transColor);
        } else {
            return null;
        }
    }

    /** {@inheritDoc} */
    @Override
    public String getMask() {
        return maskRef;
    }

    /** {@inheritDoc} */
    @Override
    public PDFReference getSoftMaskReference() {
        return softMask;
    }

    /** {@inheritDoc} */
    public PDFFilter getPDFFilter() {
        return pdfFilter;
    }

    /** {@inheritDoc} */
    public void outputContents(OutputStream out) throws IOException {
        long start = System.currentTimeMillis();
        encodingHelper.setBWInvert(true);
        encodingHelper.encode(out);
        long duration = System.currentTimeMillis() - start;
        if (log.isDebugEnabled()) {
            log.debug("Image encoding took " + duration + "ms");
        }
    }

    /** {@inheritDoc} */
    @Override
    public void populateXObjectDictionary(PDFDictionary dict) {
        ColorModel cm = getEffectiveColorModel();
        if (cm instanceof IndexColorModel) {
            IndexColorModel icm = (IndexColorModel) cm;
            super.populateXObjectDictionaryForIndexColorModel(dict, icm);
        }
    }

    /** {@inheritDoc} */
    public String getFilterHint() {
        return PDFFilterList.IMAGE_FILTER;
    }

}


text:
layout: page
title: Books
---

The number of books published about Scala is now large,
and still growing fast.

What follows is only a small selection of recent titles in English that
address the Scala language in general.  Many more books exist which
address particular audiences, particular frameworks, etc.

[**Programming in
Scala**, 3rd ed.](http://booksites.artima.com/programming_in_scala_3ed)
– **Updated for Scala 2.12**
by Martin Odersky, Lex Spoon, and Bill Venners
- first edition [available for free online reading](http://www.artima.com/pins1ed/)

Being co-written by the language's designer, Martin Odersky, you will
find it provides additional depth and clarity to the diverse features of
the language. The book provides both an authoritative reference for
Scala and a systematic tutorial covering all the features in the
language. Once you are familiar with the basics of Scala you will
appreciate having this source of invaluable examples and precise
explanations of Scala on hand. The book is available
from Artima.
Award winning book - Jolt Productivity award
for Technical Books

[**Scala for the Impatient**](http://www.horstmann.com/scala/index.html)
– **Available Now**
by Cay S. Horstmann

Published by [Addison-Wesley](http://www.pearsoned.co.uk/Imprints/Addison-Wesley/):

What you get:

 A rapid introduction to Scala for programmers who are competent in Java, C#, or C++

 Blog-length chunks of information that you can digest quickly

 An organization that you'll find useful as a quick reference

What you don't get:

 An introduction into programming or object-oriented design

 Religion about the superiority of one paradigm or another

 Cute or academic examples

 Mind-numbing details about syntax minutiae

[**Scala in Action**](http://www.manning.com/raychaudhuri)
– **Available Now**
by Nilanjan Raychaudhuri

Published by [Manning](http://www.manning.com):

"Scala in Action is a comprehensive tutorial that introduces Scala
through clear explanations and numerous hands-on examples. Because Scala
is a rich and deep language, it can be daunting to absorb all the new
concepts at once. This book takes a "how-to" approach, explaining
language concepts as you explore familiar programming challenges that
you face in your day-to-day work. You won't just get the theory of
functional programming. Instead, you'll learn to do concurrent
programming using Scala's Actors and Akka libraries. You won't just
discuss integration strategies, you'll learn to effectively mix Scala
and Spring. You won't just talk about ways to simplify programming,
you'll learn to build DSLs and other productivity tools."

[**Programming
Scala**](http://shop.oreilly.com/product/0636920033073.do)
– **Updated for Scala 2.11**
by Alex Payne and Dean Wampler

Published by [O'Reilly](http://www.oreilly.com):

Both are industry experts, Alex Payne being the lead API programmer at
Twitter, a social networking service based on
Scala. O'Reilly, the
publisher, writes:

"Learn how to be more productive with Scala, a new multi-paradigm
language for the Java Virtual Machine (JVM) that integrates features of
both object-oriented and functional programming. With this book, you'll
discover why Scala is ideal for highly scalable, component-based
applications that support concurrency and distribution. You'll also
learn how to leverage the wealth of Java class libraries to meet the
practical needs of enterprise and Internet projects more easily."

[**Functional Programming in
Scala**](https://www.manning.com/books/functional-programming-in-scala)
– **Available now**
by Paul Chiusano and Rúnar Bjarnason

Published by [Manning](http://www.manning.com):

"Functional programming (FP) is a style of software development emphasizing functions that don't depend on program state... Functional Programming in Scala is a serious tutorial for programmers looking to learn FP and apply it to the everyday business of coding. The book guides readers from basic techniques to advanced topics in a logical, concise, and clear progression. In it, you'll find concrete examples and exercises that open up the world of functional programming."

[**Scala in Depth**](http://www.manning.com/suereth)
– **Available Now**
by Joshua D. Suereth

Published by [Manning](http://www.manning.com):

"While information about the Scala language is abundant, skilled
practitioners, great examples, and insight into the best practices of
the community are harder to find. Scala in Depth bridges that gap,
preparing you to adopt Scala successfully for real world projects. Scala
in Depth is a unique new book designed to help you integrate Scala
effectively into your development process. By presenting the emerging
best practices and designs from the Scala community, it guides you
though dozens of powerful techniques example by example. There's no
heavy-handed theory here-just lots of crisp, practical guides for coding
in Scala."

[**Scala Puzzlers**](http://www.artima.com/shop/scala_puzzlers)
– **Available Now**
by Andrew Phillips and Nermin Šerifović

Published by [Artima Press](http://www.artima.com/index.jsp):

"Getting code to do what we want it to do is perhaps the essence of our purpose as developers.
So there are few things more intriguing or important than code that we think we understand, but that behaves rather contrary to our expectations.

Scala Puzzlers is a collection of such examples in Scala. It is not only an entertaining and instructive way of understanding this highly expressive language better. It will also help you recognize many counter-intuitive traps and pitfalls and prevent them from inflicting further production bug hunt stress on Scala developers."


text:
<?php

/**
 * Interface to allow edit of a poll.
 */
function template_poll_edit()
{
	global $context, $txt;

	// Some javascript for adding more options.
	echo '
	';

	if (!empty($context['form_url']))
	{
		echo '

		<form id="postmodify" name="postmodify" action="', $context['form_url'], '" method="post" accept-charset="UTF-8" onsubmit="submitonce(this); smc_saveEntities(\'postmodify\', [\'question\'], \'options-\');">

', $context['page_title'], '

';
	}

	template_show_error('poll_error');

	if (!empty($context['poll']['id']))
	{
		echo '
					<input type="hidden" name="poll" value="', $context['poll']['id'], '" />';
	}
	echo '
						<fieldset id="poll_main">
							<legend>', $txt['poll_question_options'], '</legend>
							', $txt['poll_question'], ':
							<input type="text" id="question" name="question" value="', isset($context['poll']['question']) ? $context['poll']['question'] : '', '" tabindex="', $context['tabindex']++, '" size="80" class="input_text" required="required" placeholder="', $txt['poll_question'], '" />

';

	// Loop through all the choices and print them out.
	foreach ($context['poll']['choices'] as $choice)
	{
		echo '

									', $txt['option'], ' ', $choice['number'], ':
									<input type="text" name="options[', $choice['id'], ']" id="options-', $choice['id'], '" value="', $choice['label'], '" tabindex="', $context['tabindex']++, '" size="80" maxlength="255" class="input_text" />';

		// Does this option have a vote count yet, or is it new?
		if (isset($choice['votes']) && $choice['votes'] != -1)
		{
			echo ' (', $choice['votes'], ' ', $txt['votes'], ')';
		}

		echo '

';
	}

	echo '

							', $txt['poll_add_option'], '
						</fieldset>
						<fieldset id="poll_options">
							<legend>', $txt['poll_options'], ':</legend>

';

	if ($context['can_moderate_poll'])
	{
		echo '

									', $txt['poll_max_votes'], ':

									<input type="text" name="poll_max_votes" id="poll_max_votes" size="2" value="', $context['poll']['max_votes'], '" class="input_text" />

									', $txt['poll_run'], ':

									', $txt['poll_run_limit'], '

									<input type="text" name="poll_expire" id="poll_expire" size="2" value="', $context['poll']['expiration'], '" onchange="pollOptions();" maxlength="4" class="input_text" /> ', $txt['days_word'], '

									', $txt['poll_do_change_vote'], ':

									<input type="checkbox" id="poll_change_vote" name="poll_change_vote"', !empty($context['poll']['change_vote']) ? ' checked="checked"' : '', ' />

';

		if ($context['poll']['guest_vote_allowed'])
		{
			echo '

									', $txt['poll_guest_vote'], ':

									<input type="checkbox" id="poll_guest_vote" name="poll_guest_vote"', !empty($context['poll']['guest_vote']) ? ' checked="checked"' : '', ' />

';
		}
	}

	echo '

									', $txt['poll_results_visibility'], ':

										<input type="radio" name="poll_hide" id="poll_results_anyone" value="0"', $context['poll']['hide_results'] == 0 ? ' checked="checked"' : '', ' /> ', $txt['poll_results_anyone'], '

										<input type="radio" name="poll_hide" id="poll_results_voted" value="1"', $context['poll']['hide_results'] == 1 ? ' checked="checked"' : '', ' /> ', $txt['poll_results_voted'], '

										<input type="radio" name="poll_hide" id="poll_results_expire" value="2"', $context['poll']['hide_results'] == 2 ? ' checked="checked"' : '', empty($context['poll']['expiration']) ? ' disabled="disabled"' : '', ' /> ', $txt['poll_results_after'], '

						</fieldset>';

	// If this is an edit, we can allow them to reset the vote counts.
	// @todo a warning maybe while saving?
	if (!empty($context['is_edit']))
	{
		echo '
					<fieldset id="poll_reset">
						<legend>', $txt['reset_votes'], '</legend>
						<input type="checkbox" id="resetVoteCount" name="resetVoteCount" value="on" /> ' . $txt['reset_votes_check'] . '
					</fieldset>';
	}

	if (!empty($context['form_url']))
	{
		echo '

						<input type="submit" name="post" value="', $txt['save'], '" onclick="return submitThisOnce(this);" accesskey="s" />
						<input type="hidden" name="', $context['session_var'], '" value="', $context['session_id'], '" />
						<input type="hidden" name="seqnum" value="', $context['form_sequence_number'], '" />

		</form>

';
	}
}


text:
/**
 * Autogenerated by Thrift
 *
 * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
 */

namespace Leansoft.BigQueue.Thrift
{
  public enum ResultCode
  {
    SUCCESS = 0,
    FAILURE = 1,
  }
}


text:
<?php

/**
*
*/

defined('BASEPATH') OR exit('No direct script access allowed');

class form2 extends CI_Controller
{

	function __construct()
	{
		parent::__construct();# code...
	}
	public function index(){
		$this->load->helper('url');
		$this->load->view('form2');
	}
}

 ?>


text:
cp named.conf /etc/bind/
cp named.conf.local /etc/bind
cp named.conf.options /etc/bind
cp keys.conf /etc/bind
mkdir -p /var/cache/bind/zones
chown bind:bind -R /var/cache/bind
cp db.{{.Xpname}}.cypress.net /var/cache/bind/zones

#cp usr.sbin.named /etc/apparmor.d/local/
#apparmor_parser -r /etc/apparmor.d/usr.sbin.named

service bind9 restart


text:
//
//  ObjcMyView.h
//  swift-nsimagerep-planedata-example
//
//  Created by dolphilia on 2016/01/15.
//  Copyright © 2016年 dolphilia. All rights reserved.
//

#ifndef ObjcMyView_h
#define ObjcMyView_h

#import <Cocoa/Cocoa.h>

@interface ObjcMyView : NSView {
    NSImage* image;
    NSTimer *timer_;
}

- (void)onThread;

@end

#endif /* ObjcMyView_h */


text:
/*************************************************************************/
/*  tile_map.cpp                                                         */
/*************************************************************************/
/*                       This file is part of:                           */
/*                           GODOT ENGINE                                */
/*                      https://godotengine.org                          */
/*************************************************************************/
/* Copyright (c) 2007-2017 Juan Linietsky, Ariel Manzur.                 */
/* Copyright (c) 2014-2017 Godot Engine contributors (cf. AUTHORS.md)    */
/*                                                                       */
/* Permission is hereby granted, free of charge, to any person obtaining */
/* a copy of this software and associated documentation files (the       */
/* "Software"), to deal in the Software without restriction, including   */
/* without limitation the rights to use, copy, modify, merge, publish,   */
/* distribute, sublicense, and/or sell copies of the Software, and to    */
/* permit persons to whom the Software is furnished to do so, subject to */
/* the following conditions:                                             */
/*                                                                       */
/* The above copyright notice and this permission notice shall be        */
/* included in all copies or substantial portions of the Software.       */
/*                                                                       */
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
/*************************************************************************/
#include "tile_map.h"
#include "io/marshalls.h"
#include "method_bind_ext.gen.inc"
#include "os/os.h"
#include "servers/physics_2d_server.h"

int TileMap::_get_quadrant_size() const {

	if (y_sort_mode)
		return 1;
	else
		return quadrant_size;
}

void TileMap::_notification(int p_what) {

	switch (p_what) {

		case NOTIFICATION_ENTER_TREE: {

			Node2D *c = this;
			while (c) {

				navigation = Object::cast_to<Navigation2D>(c);
				if (navigation) {
					break;
				}

				c = Object::cast_to<Node2D>(c->get_parent());
			}

			pending_update = true;
			_update_dirty_quadrants();
			RID space = get_world_2d()->get_space();
			_update_quadrant_transform();
			_update_quadrant_space(space);

		} break;
		case NOTIFICATION_EXIT_TREE: {

			_update_quadrant_space(RID());
			for (Map<PosKey, Quadrant>::Element *E = quadrant_map.front(); E; E = E->next()) {

				Quadrant &q = E->get();
				if (navigation) {
					for (Map<PosKey, Quadrant::NavPoly>::Element *E = q.navpoly_ids.front(); E; E = E->next()) {

						navigation->navpoly_remove(E->get().id);
					}
					q.navpoly_ids.clear();
				}

				for (Map<PosKey, Quadrant::Occluder>::Element *E = q.occluder_instances.front(); E; E = E->next()) {
					VS::get_singleton()->free(E->get().id);
				}
				q.occluder_instances.clear();
			}

			navigation = NULL;

		} break;
		case NOTIFICATION_TRANSFORM_CHANGED: {

			//move stuff
			_update_quadrant_transform();

		} break;
	}
}

void TileMap::_update_quadrant_space(const RID &p_space) {

	for (Map<PosKey, Quadrant>::Element *E = quadrant_map.front(); E; E = E->next()) {

		Quadrant &q = E->get();
		Physics2DServer::get_singleton()->body_set_space(q.body, p_space);
	}
}

void TileMap::_update_quadrant_transform() {

	if (!is_inside_tree())
		return;

	Transform2D global_transform = get_global_transform();

	Transform2D nav_rel;
	if (navigation)
		nav_rel = get_relative_transform_to_parent(navigation);

	for (Map<PosKey, Quadrant>::Element *E = quadrant_map.front(); E; E = E->next()) {

		Quadrant &q = E->get();
		Transform2D xform;
		xform.set_origin(q.pos);
		xform = global_transform * xform;
		Physics2DServer::get_singleton()->body_set_state(q.body, Physics2DServer::BODY_STATE_TRANSFORM, xform);

		if (navigation) {
			for (Map<PosKey, Quadrant::NavPoly>::Element *E = q.navpoly_ids.front(); E; E = E->next()) {

				navigation->navpoly_set_transform(E->get().id, nav_rel * E->get().xform);
			}
		}

		for (Map<PosKey, Quadrant::Occluder>::Element *E = q.occluder_instances.front(); E; E = E->next()) {
			VS::get_singleton()->canvas_light_occluder_set_transform(E->get().id, global_transform * E->get().xform);
		}
	}
}

void TileMap::set_tileset(const Ref<TileSet> &p_tileset) {

	if (tile_set.is_valid())
		tile_set->disconnect("changed", this, "_recreate_quadrants");

	_clear_quadrants();
	tile_set = p_tileset;

	if (tile_set.is_valid())
		tile_set->connect("changed", this, "_recreate_quadrants");
	else
		clear();

	_recreate_quadrants();
	emit_signal("settings_changed");
}

Ref<TileSet> TileMap::get_tileset() const {

	return tile_set;
}

void TileMap::set_cell_size(Size2 p_size) {

	ERR_FAIL_COND(p_size.x < 1 || p_size.y < 1);

	_clear_quadrants();
	cell_size = p_size;
	_recreate_quadrants();
	emit_signal("settings_changed");
}
Size2 TileMap::get_cell_size() const {

	return cell_size;
}
void TileMap::set_quadrant_size(int p_size) {

	ERR_FAIL_COND(p_size < 1);

	_clear_quadrants();
	quadrant_size = p_size;
	_recreate_quadrants();
	emit_signal("settings_changed");
}
int TileMap::get_quadrant_size() const {

	return quadrant_size;
}

void TileMap::set_center_x(bool p_enable) {

	center_x = p_enable;
	_recreate_quadrants();
	emit_signal("settings_changed");
}
bool TileMap::get_center_x() const {

	return center_x;
}
void TileMap::set_center_y(bool p_enable) {

	center_y = p_enable;
	_recreate_quadrants();
	emit_signal("settings_changed");
}
bool TileMap::get_center_y() const {

	return center_y;
}

void TileMap::_fix_cell_transform(Transform2D &xform, const Cell &p_cell, const Vector2 &p_offset, const Size2 &p_sc) {

	Size2 s = p_sc;
	Vector2 offset = p_offset;

	if (tile_origin == TILE_ORIGIN_BOTTOM_LEFT)
		offset.y += cell_size.y;

	if (s.y > s.x) {
		if ((p_cell.flip_h && (p_cell.flip_v || p_cell.transpose)) || (p_cell.flip_v && !p_cell.transpose))
			offset.y += s.y - s.x;
	} else if (s.y < s.x) {
		if ((p_cell.flip_v && (p_cell.flip_h || p_cell.transpose)) || (p_cell.flip_h && !p_cell.transpose))
			offset.x += s.x - s.y;
	}

	if (p_cell.transpose) {
		SWAP(xform.elements[0].x, xform.elements[0].y);
		SWAP(xform.elements[1].x, xform.elements[1].y);
		SWAP(offset.x, offset.y);
		SWAP(s.x, s.y);
	}
	if (p_cell.flip_h) {
		xform.elements[0].x = -xform.elements[0].x;
		xform.elements[1].x = -xform.elements[1].x;
		if (tile_origin == TILE_ORIGIN_TOP_LEFT || tile_origin == TILE_ORIGIN_BOTTOM_LEFT)
			offset.x = s.x - offset.x;
	}
	if (p_cell.flip_v) {
		xform.elements[0].y = -xform.elements[0].y;
		xform.elements[1].y = -xform.elements[1].y;
		if (tile_origin == TILE_ORIGIN_TOP_LEFT)
			offset.y = s.y - offset.y;
		else if (tile_origin == TILE_ORIGIN_BOTTOM_LEFT) {
			if (p_cell.transpose)
				offset.y += s.y;
			else
				offset.y -= s.y;
		}
	}
	xform.elements[2].x += offset.x;
	xform.elements[2].y += offset.y;
}

void TileMap::_update_dirty_quadrants() {

	if (!pending_update)
		return;
	if (!is_inside_tree() || !tile_set.is_valid()) {
		pending_update = false;
		return;
	}

	VisualServer *vs = VisualServer::get_singleton();
	Physics2DServer *ps = Physics2DServer::get_singleton();
	Vector2 tofs = get_cell_draw_offset();
	Vector2 tcenter = cell_size / 2;
	Transform2D nav_rel;
	if (navigation)
		nav_rel = get_relative_transform_to_parent(navigation);

	Vector2 qofs;

	SceneTree *st = SceneTree::get_singleton();
	Color debug_collision_color;

	bool debug_shapes = st && st->is_debugging_collisions_hint();
	if (debug_shapes) {
		debug_collision_color = st->get_debug_collisions_color();
	}

	while (dirty_quadrant_list.first()) {

		Quadrant &q = *dirty_quadrant_list.first()->self();

		for (List<RID>::Element *E = q.canvas_items.front(); E; E = E->next()) {

			vs->free(E->get());
		}

		q.canvas_items.clear();

		ps->body_clear_shapes(q.body);
		int shape_idx = 0;

		if (navigation) {
			for (Map<PosKey, Quadrant::NavPoly>::Element *E = q.navpoly_ids.front(); E; E = E->next()) {

				navigation->navpoly_remove(E->get().id);
			}
			q.navpoly_ids.clear();
		}

		for (Map<PosKey, Quadrant::Occluder>::Element *E = q.occluder_instances.front(); E; E = E->next()) {
			VS::get_singleton()->free(E->get().id);
		}
		q.occluder_instances.clear();
		Ref<ShaderMaterial> prev_material;
		RID prev_canvas_item;
		RID prev_debug_canvas_item;

		for (int i = 0; i < q.cells.size(); i++) {

			Map<PosKey, Cell>::Element *E = tile_map.find(q.cells[i]);
			Cell &c = E->get();
			//moment of truth
			if (!tile_set->has_tile(c.id))
				continue;
			Ref<Texture> tex = tile_set->tile_get_texture(c.id);
			Vector2 tile_ofs = tile_set->tile_get_texture_offset(c.id);

			Vector2 wofs = _map_to_world(E->key().x, E->key().y);
			Vector2 offset = wofs - q.pos + tofs;

			if (!tex.is_valid())
				continue;

			Ref<ShaderMaterial> mat = tile_set->tile_get_material(c.id);

			RID canvas_item;
			RID debug_canvas_item;

			if (prev_canvas_item == RID() || prev_material != mat) {

				canvas_item = vs->canvas_item_create();
				if (mat.is_valid())
					vs->canvas_item_set_material(canvas_item, mat->get_rid());
				vs->canvas_item_set_parent(canvas_item, get_canvas_item());
				_update_item_material_state(canvas_item);
				Transform2D xform;
				xform.set_origin(q.pos);
				vs->canvas_item_set_transform(canvas_item, xform);
				vs->canvas_item_set_light_mask(canvas_item, get_light_mask());

				q.canvas_items.push_back(canvas_item);

				if (debug_shapes) {

					debug_canvas_item = vs->canvas_item_create();
					vs->canvas_item_set_parent(debug_canvas_item, canvas_item);
					vs->canvas_item_set_z_as_relative_to_parent(debug_canvas_item, false);
					vs->canvas_item_set_z(debug_canvas_item, VS::CANVAS_ITEM_Z_MAX - 1);
					q.canvas_items.push_back(debug_canvas_item);
					prev_debug_canvas_item = debug_canvas_item;
				}

				prev_canvas_item = canvas_item;
				prev_material = mat;

			} else {
				canvas_item = prev_canvas_item;
				if (debug_shapes) {
					debug_canvas_item = prev_debug_canvas_item;
				}
			}

			Rect2 r = tile_set->tile_get_region(c.id);
			Size2 s = tex->get_size();

			if (r == Rect2())
				s = tex->get_size();
			else {
				s = r.size;
			}

			Rect2 rect;
			rect.position = offset.floor();
			rect.size = s;
			rect.size.x += fp_adjust;
			rect.size.y += fp_adjust;

			if (rect.size.y > rect.size.x) {
				if ((c.flip_h && (c.flip_v || c.transpose)) || (c.flip_v && !c.transpose))
					tile_ofs.y += rect.size.y - rect.size.x;
			} else if (rect.size.y < rect.size.x) {
				if ((c.flip_v && (c.flip_h || c.transpose)) || (c.flip_h && !c.transpose))
					tile_ofs.x += rect.size.x - rect.size.y;
			}

			/*	rect.size.x+=fp_adjust;
			rect.size.y+=fp_adjust;*/

			if (c.transpose)
				SWAP(tile_ofs.x, tile_ofs.y);

			if (c.flip_h) {
				rect.size.x = -rect.size.x;
				tile_ofs.x = -tile_ofs.x;
			}
			if (c.flip_v) {
				rect.size.y = -rect.size.y;
				tile_ofs.y = -tile_ofs.y;
			}

			Vector2 center_ofs;

			if (tile_origin == TILE_ORIGIN_TOP_LEFT) {
				rect.position += tile_ofs;

			} else if (tile_origin == TILE_ORIGIN_BOTTOM_LEFT) {

				rect.position += tile_ofs;

				if (c.transpose) {
					if (c.flip_h)
						rect.position.x -= cell_size.x;
					else
						rect.position.x += cell_size.x;
				} else {
					if (c.flip_v)
						rect.position.y -= cell_size.y;
					else
						rect.position.y += cell_size.y;
				}

			} else if (tile_origin == TILE_ORIGIN_CENTER) {
				rect.position += tcenter;

				Vector2 center = (s / 2) - tile_ofs;
				center_ofs = tcenter - (s / 2);

				if (c.flip_h)
					rect.position.x -= s.x - center.x;
				else
					rect.position.x -= center.x;

				if (c.flip_v)
					rect.position.y -= s.y - center.y;
				else
					rect.position.y -= center.y;
			}

			Ref<Texture> normal_map = tile_set->tile_get_normal_map(c.id);
			Color modulate = tile_set->tile_get_modulate(c.id);
			Color self_modulate = get_self_modulate();
			modulate = Color(modulate.r * self_modulate.r, modulate.g * self_modulate.g,
					modulate.b * self_modulate.b, modulate.a * self_modulate.a);
			if (r == Rect2()) {
				tex->draw_rect(canvas_item, rect, false, modulate, c.transpose, normal_map);
			} else {
				tex->draw_rect_region(canvas_item, rect, r, modulate, c.transpose, normal_map, clip_uv);
			}

			Vector<TileSet::ShapeData> shapes = tile_set->tile_get_shapes(c.id);

			for (int i = 0; i < shapes.size(); i++) {
				Ref<Shape2D> shape = shapes[i].shape;
				if (shape.is_valid()) {
					Transform2D xform;
					xform.set_origin(offset.floor());

					Vector2 shape_ofs = tile_set->tile_get_shape_offset(c.id, i);

					_fix_cell_transform(xform, c, shape_ofs + center_ofs, s);

					if (debug_canvas_item.is_valid()) {
						vs->canvas_item_add_set_transform(debug_canvas_item, xform);
						shape->draw(debug_canvas_item, debug_collision_color);
					}
					ps->body_add_shape(q.body, shape->get_rid(), xform);
					ps->body_set_shape_metadata(q.body, shape_idx, Vector2(E->key().x, E->key().y));
					ps->body_set_shape_as_one_way_collision(q.body, shape_idx, shapes[i].one_way_collision);
					shape_idx++;
				}
			}

			if (debug_canvas_item.is_valid()) {
				vs->canvas_item_add_set_transform(debug_canvas_item, Transform2D());
			}

			if (navigation) {
				Ref<NavigationPolygon> navpoly = tile_set->tile_get_navigation_polygon(c.id);
				if (navpoly.is_valid()) {
					Vector2 npoly_ofs = tile_set->tile_get_navigation_polygon_offset(c.id);
					Transform2D xform;
					xform.set_origin(offset.floor() + q.pos);
					_fix_cell_transform(xform, c, npoly_ofs + center_ofs, s);

					int pid = navigation->navpoly_create(navpoly, nav_rel * xform);

					Quadrant::NavPoly np;
					np.id = pid;
					np.xform = xform;
					q.navpoly_ids[E->key()] = np;
				}
			}

			Ref<OccluderPolygon2D> occluder = tile_set->tile_get_light_occluder(c.id);
			if (occluder.is_valid()) {

				Vector2 occluder_ofs = tile_set->tile_get_occluder_offset(c.id);
				Transform2D xform;
				xform.set_origin(offset.floor() + q.pos);
				_fix_cell_transform(xform, c, occluder_ofs + center_ofs, s);

				RID orid = VS::get_singleton()->canvas_light_occluder_create();
				VS::get_singleton()->canvas_light_occluder_set_transform(orid, get_global_transform() * xform);
				VS::get_singleton()->canvas_light_occluder_set_polygon(orid, occluder->get_rid());
				VS::get_singleton()->canvas_light_occluder_attach_to_canvas(orid, get_canvas());
				VS::get_singleton()->canvas_light_occluder_set_light_mask(orid, occluder_light_mask);
				Quadrant::Occluder oc;
				oc.xform = xform;
				oc.id = orid;
				q.occluder_instances[E->key()] = oc;
			}
		}

		dirty_quadrant_list.remove(dirty_quadrant_list.first());
		quadrant_order_dirty = true;
	}

	pending_update = false;

	if (quadrant_order_dirty) {

		int index = -0x80000000; //always must be drawn below children
		for (Map<PosKey, Quadrant>::Element *E = quadrant_map.front(); E; E = E->next()) {

			Quadrant &q = E->get();
			for (List<RID>::Element *E = q.canvas_items.front(); E; E = E->next()) {

				VS::get_singleton()->canvas_item_set_draw_index(E->get(), index++);
			}
		}

		quadrant_order_dirty = false;
	}

	_recompute_rect_cache();
}

void TileMap::_recompute_rect_cache() {

#ifdef DEBUG_ENABLED

	if (!rect_cache_dirty)
		return;

	Rect2 r_total;
	for (Map<PosKey, Quadrant>::Element *E = quadrant_map.front(); E; E = E->next()) {

		Rect2 r;
		r.position = _map_to_world(E->key().x * _get_quadrant_size(), E->key().y * _get_quadrant_size());
		r.expand_to(_map_to_world(E->key().x * _get_quadrant_size() + _get_quadrant_size(), E->key().y * _get_quadrant_size()));
		r.expand_to(_map_to_world(E->key().x * _get_quadrant_size() + _get_quadrant_size(), E->key().y * _get_quadrant_size() + _get_quadrant_size()));
		r.expand_to(_map_to_world(E->key().x * _get_quadrant_size(), E->key().y * _get_quadrant_size() + _get_quadrant_size()));
		if (E == quadrant_map.front())
			r_total = r;
		else
			r_total = r_total.merge(r);
	}

	if (r_total == Rect2()) {
		rect_cache = Rect2(-10, -10, 20, 20);
	} else {
		rect_cache = r_total.grow(MAX(cell_size.x, cell_size.y) * _get_quadrant_size());
	}

	item_rect_changed();

	rect_cache_dirty = false;
#endif
}

Map<TileMap::PosKey, TileMap::Quadrant>::Element *TileMap::_create_quadrant(const PosKey &p_qk) {

	Transform2D xform;
	//xform.set_origin(Point2(p_qk.x,p_qk.y)*cell_size*quadrant_size);
	Quadrant q;
	q.pos = _map_to_world(p_qk.x * _get_quadrant_size(), p_qk.y * _get_quadrant_size());
	q.pos += get_cell_draw_offset();
	if (tile_origin == TILE_ORIGIN_CENTER)
		q.pos += cell_size / 2;
	else if (tile_origin == TILE_ORIGIN_BOTTOM_LEFT)
		q.pos.y += cell_size.y;

	xform.set_origin(q.pos);
	//q.canvas_item = VisualServer::get_singleton()->canvas_item_create();
	q.body = Physics2DServer::get_singleton()->body_create();
	Physics2DServer::get_singleton()->body_set_mode(q.body, use_kinematic ? Physics2DServer::BODY_MODE_KINEMATIC : Physics2DServer::BODY_MODE_STATIC);

	Physics2DServer::get_singleton()->body_attach_object_instance_id(q.body, get_instance_id());
	Physics2DServer::get_singleton()->body_set_collision_layer(q.body, collision_layer);
	Physics2DServer::get_singleton()->body_set_collision_mask(q.body, collision_mask);
	Physics2DServer::get_singleton()->body_set_param(q.body, Physics2DServer::BODY_PARAM_FRICTION, friction);
	Physics2DServer::get_singleton()->body_set_param(q.body, Physics2DServer::BODY_PARAM_BOUNCE, bounce);

	if (is_inside_tree()) {
		xform = get_global_transform() * xform;
		RID space = get_world_2d()->get_space();
		Physics2DServer::get_singleton()->body_set_space(q.body, space);
	}

	Physics2DServer::get_singleton()->body_set_state(q.body, Physics2DServer::BODY_STATE_TRANSFORM, xform);

	rect_cache_dirty = true;
	quadrant_order_dirty = true;
	return quadrant_map.insert(p_qk, q);
}

void TileMap::_erase_quadrant(Map<PosKey, Quadrant>::Element *Q) {

	Quadrant &q = Q->get();
	Physics2DServer::get_singleton()->free(q.body);
	for (List<RID>::Element *E = q.canvas_items.front(); E; E = E->next()) {

		VisualServer::get_singleton()->free(E->get());
	}
	q.canvas_items.clear();
	if (q.dirty_list.in_list())
		dirty_quadrant_list.remove(&q.dirty_list);

	if (navigation) {
		for (Map<PosKey, Quadrant::NavPoly>::Element *E = q.navpoly_ids.front(); E; E = E->next()) {

			navigation->navpoly_remove(E->get().id);
		}
		q.navpoly_ids.clear();
	}

	for (Map<PosKey, Quadrant::Occluder>::Element *E = q.occluder_instances.front(); E; E = E->next()) {
		VS::get_singleton()->free(E->get().id);
	}
	q.occluder_instances.clear();

	quadrant_map.erase(Q);
	rect_cache_dirty = true;
}

void TileMap::_make_quadrant_dirty(Map<PosKey, Quadrant>::Element *Q) {

	Quadrant &q = Q->get();
	if (!q.dirty_list.in_list())
		dirty_quadrant_list.add(&q.dirty_list);

	if (pending_update)
		return;
	pending_update = true;
	if (!is_inside_tree())
		return;
	call_deferred("_update_dirty_quadrants");
}

void TileMap::set_cellv(const Vector2 &p_pos, int p_tile, bool p_flip_x, bool p_flip_y, bool p_transpose) {

	set_cell(p_pos.x, p_pos.y, p_tile, p_flip_x, p_flip_y, p_transpose);
}

void TileMap::set_cell(int p_x, int p_y, int p_tile, bool p_flip_x, bool p_flip_y, bool p_transpose) {

	PosKey pk(p_x, p_y);

	Map<PosKey, Cell>::Element *E = tile_map.find(pk);
	if (!E && p_tile == INVALID_CELL)
		return; //nothing to do

	PosKey qk(p_x / _get_quadrant_size(), p_y / _get_quadrant_size());
	if (p_tile == INVALID_CELL) {
		//erase existing
		tile_map.erase(pk);
		Map<PosKey, Quadrant>::Element *Q = quadrant_map.find(qk);
		ERR_FAIL_COND(!Q);
		Quadrant &q = Q->get();
		q.cells.erase(pk);
		if (q.cells.size() == 0)
			_erase_quadrant(Q);
		else
			_make_quadrant_dirty(Q);

		return;
	}

	Map<PosKey, Quadrant>::Element *Q = quadrant_map.find(qk);

	if (!E) {
		E = tile_map.insert(pk, Cell());
		if (!Q) {
			Q = _create_quadrant(qk);
		}
		Quadrant &q = Q->get();
		q.cells.insert(pk);
	} else {
		ERR_FAIL_COND(!Q); // quadrant should exist...

		if (E->get().id == p_tile && E->get().flip_h == p_flip_x && E->get().flip_v == p_flip_y && E->get().transpose == p_transpose)
			return; //nothing changed
	}

	Cell &c = E->get();

	c.id = p_tile;
	c.flip_h = p_flip_x;
	c.flip_v = p_flip_y;
	c.transpose = p_transpose;

	_make_quadrant_dirty(Q);
	used_size_cache_dirty = true;
}

int TileMap::get_cellv(const Vector2 &p_pos) const {
	return get_cell(p_pos.x, p_pos.y);
}

int TileMap::get_cell(int p_x, int p_y) const {

	PosKey pk(p_x, p_y);

	const Map<PosKey, Cell>::Element *E = tile_map.find(pk);

	if (!E)
		return INVALID_CELL;

	return E->get().id;
}
bool TileMap::is_cell_x_flipped(int p_x, int p_y) const {

	PosKey pk(p_x, p_y);

	const Map<PosKey, Cell>::Element *E = tile_map.find(pk);

	if (!E)
		return false;

	return E->get().flip_h;
}
bool TileMap::is_cell_y_flipped(int p_x, int p_y) const {

	PosKey pk(p_x, p_y);

	const Map<PosKey, Cell>::Element *E = tile_map.find(pk);

	if (!E)
		return false;

	return E->get().flip_v;
}
bool TileMap::is_cell_transposed(int p_x, int p_y) const {

	PosKey pk(p_x, p_y);

	const Map<PosKey, Cell>::Element *E = tile_map.find(pk);

	if (!E)
		return false;

	return E->get().transpose;
}

void TileMap::_recreate_quadrants() {

	_clear_quadrants();

	for (Map<PosKey, Cell>::Element *E = tile_map.front(); E; E = E->next()) {

		PosKey qk(E->key().x / _get_quadrant_size(), E->key().y / _get_quadrant_size());

		Map<PosKey, Quadrant>::Element *Q = quadrant_map.find(qk);
		if (!Q) {
			Q = _create_quadrant(qk);
			dirty_quadrant_list.add(&Q->get().dirty_list);
		}

		Q->get().cells.insert(E->key());
		_make_quadrant_dirty(Q);
	}
}

void TileMap::_clear_quadrants() {

	while (quadrant_map.size()) {
		_erase_quadrant(quadrant_map.front());
	}
}

void TileMap::set_material(const Ref<Material> &p_material) {

	CanvasItem::set_material(p_material);
	_update_all_items_material_state();
}

void TileMap::set_use_parent_material(bool p_use_parent_material) {

	CanvasItem::set_use_parent_material(p_use_parent_material);
	_update_all_items_material_state();
}

void TileMap::_update_all_items_material_state() {

	for (Map<PosKey, Quadrant>::Element *E = quadrant_map.front(); E; E = E->next()) {

		Quadrant &q = E->get();
		for (List<RID>::Element *E = q.canvas_items.front(); E; E = E->next()) {

			_update_item_material_state(E->get());
		}
	}
}

void TileMap::_update_item_material_state(const RID &p_canvas_item) {

	VS::get_singleton()->canvas_item_set_use_parent_material(p_canvas_item, get_use_parent_material() || get_material().is_valid());
}

void TileMap::clear() {

	_clear_quadrants();
	tile_map.clear();
	used_size_cache_dirty = true;
}

void TileMap::_set_tile_data(const PoolVector<int> &p_data) {

	int c = p_data.size();
	PoolVector<int>::Read r = p_data.read();

	for (int i = 0; i < c; i += 2) {

		const uint8_t *ptr = (const uint8_t *)&r[i];
		uint8_t local[8];
		for (int j = 0; j < 8; j++)
			local[j] = ptr[j];

#ifdef BIG_ENDIAN_ENABLED

		SWAP(local[0], local[3]);
		SWAP(local[1], local[2]);
		SWAP(local[4], local[7]);
		SWAP(local[5], local[6]);
#endif

		int16_t x = decode_uint16(&local[0]);
		int16_t y = decode_uint16(&local[2]);
		uint32_t v = decode_uint32(&local[4]);
		bool flip_h = v & (1 << 29);
		bool flip_v = v & (1 << 30);
		bool transpose = v & (1 << 31);
		v &= (1 << 29) - 1;

		/*
		if (x<-20 || y <-20 || x>4000 || y>4000)
			continue;
		*/
		set_cell(x, y, v, flip_h, flip_v, transpose);
	}
}

PoolVector<int> TileMap::_get_tile_data() const {

	PoolVector<int> data;
	data.resize(tile_map.size() * 2);
	PoolVector<int>::Write w = data.write();

	int idx = 0;
	for (const Map<PosKey, Cell>::Element *E = tile_map.front(); E; E = E->next()) {

		uint8_t *ptr = (uint8_t *)&w[idx];
		encode_uint16(E->key().x, &ptr[0]);
		encode_uint16(E->key().y, &ptr[2]);
		uint32_t val = E->get().id;
		if (E->get().flip_h)
			val |= (1 << 29);
		if (E->get().flip_v)
			val |= (1 << 30);
		if (E->get().transpose)
			val |= (1 << 31);

		encode_uint32(val, &ptr[4]);
		idx += 2;
	}

	w = PoolVector<int>::Write();

	return data;
}

Rect2 TileMap::get_item_rect() const {

	const_cast<TileMap *>(this)->_update_dirty_quadrants();
	return rect_cache;
}

void TileMap::set_collision_layer(uint32_t p_layer) {

	collision_layer = p_layer;
	for (Map<PosKey, Quadrant>::Element *E = quadrant_map.front(); E; E = E->next()) {

		Quadrant &q = E->get();
		Physics2DServer::get_singleton()->body_set_collision_layer(q.body, collision_layer);
	}
}

void TileMap::set_collision_mask(uint32_t p_mask) {

	collision_mask = p_mask;
	for (Map<PosKey, Quadrant>::Element *E = quadrant_map.front(); E; E = E->next()) {

		Quadrant &q = E->get();
		Physics2DServer::get_singleton()->body_set_collision_mask(q.body, collision_mask);
	}
}

void TileMap::set_collision_layer_bit(int p_bit, bool p_value) {

	uint32_t layer = get_collision_layer();
	if (p_value)
		layer |= 1 << p_bit;
	else
		layer &= ~(1 << p_bit);
	set_collision_layer(layer);
}

void TileMap::set_collision_mask_bit(int p_bit, bool p_value) {

	uint32_t mask = get_collision_mask();
	if (p_value)
		mask |= 1 << p_bit;
	else
		mask &= ~(1 << p_bit);
	set_collision_mask(mask);
}

bool TileMap::get_collision_use_kinematic() const {

	return use_kinematic;
}

void TileMap::set_collision_use_kinematic(bool p_use_kinematic) {

	_clear_quadrants();
	use_kinematic = p_use_kinematic;
	_recreate_quadrants();
}

void TileMap::set_collision_friction(float p_friction) {

	friction = p_friction;
	for (Map<PosKey, Quadrant>::Element *E = quadrant_map.front(); E; E = E->next()) {

		Quadrant &q = E->get();
		Physics2DServer::get_singleton()->body_set_param(q.body, Physics2DServer::BODY_PARAM_FRICTION, p_friction);
	}
}

float TileMap::get_collision_friction() const {

	return friction;
}

void TileMap::set_collision_bounce(float p_bounce) {

	bounce = p_bounce;
	for (Map<PosKey, Quadrant>::Element *E = quadrant_map.front(); E; E = E->next()) {

		Quadrant &q = E->get();
		Physics2DServer::get_singleton()->body_set_param(q.body, Physics2DServer::BODY_PARAM_BOUNCE, p_bounce);
	}
}
float TileMap::get_collision_bounce() const {

	return bounce;
}

uint32_t TileMap::get_collision_layer() const {

	return collision_layer;
}

uint32_t TileMap::get_collision_mask() const {

	return collision_mask;
}

bool TileMap::get_collision_layer_bit(int p_bit) const {

	return get_collision_layer() & (1 << p_bit);
}

bool TileMap::get_collision_mask_bit(int p_bit) const {

	return get_collision_mask() & (1 << p_bit);
}

void TileMap::set_mode(Mode p_mode) {

	_clear_quadrants();
	mode = p_mode;
	_recreate_quadrants();
	emit_signal("settings_changed");
}

TileMap::Mode TileMap::get_mode() const {
	return mode;
}

void TileMap::set_half_offset(HalfOffset p_half_offset) {

	_clear_quadrants();
	half_offset = p_half_offset;
	_recreate_quadrants();
	emit_signal("settings_changed");
}

void TileMap::set_tile_origin(TileOrigin p_tile_origin) {

	_clear_quadrants();
	tile_origin = p_tile_origin;
	_recreate_quadrants();
	emit_signal("settings_changed");
}

TileMap::TileOrigin TileMap::get_tile_origin() const {

	return tile_origin;
}

Vector2 TileMap::get_cell_draw_offset() const {

	switch (mode) {

		case MODE_SQUARE: {

			return Vector2();
		} break;
		case MODE_ISOMETRIC: {

			return Vector2(-cell_size.x * 0.5, 0);

		} break;
		case MODE_CUSTOM: {

			Vector2 min;
			min.x = MIN(custom_transform[0].x, min.x);
			min.y = MIN(custom_transform[0].y, min.y);
			min.x = MIN(custom_transform[1].x, min.x);
			min.y = MIN(custom_transform[1].y, min.y);
			return min;
		} break;
	}

	return Vector2();
}

TileMap::HalfOffset TileMap::get_half_offset() const {
	return half_offset;
}

Transform2D TileMap::get_cell_transform() const {

	switch (mode) {

		case MODE_SQUARE: {

			Transform2D m;
			m[0] *= cell_size.x;
			m[1] *= cell_size.y;
			return m;
		} break;
		case MODE_ISOMETRIC: {

			//isometric only makes sense when y is positive in both x and y vectors, otherwise
			//the drawing of tiles will overlap
			Transform2D m;
			m[0] = Vector2(cell_size.x * 0.5, cell_size.y * 0.5);
			m[1] = Vector2(-cell_size.x * 0.5, cell_size.y * 0.5);
			return m;

		} break;
		case MODE_CUSTOM: {

			return custom_transform;
		} break;
	}

	return Transform2D();
}

void TileMap::set_custom_transform(const Transform2D &p_xform) {

	_clear_quadrants();
	custom_transform = p_xform;
	_recreate_quadrants();
	emit_signal("settings_changed");
}

Transform2D TileMap::get_custom_transform() const {

	return custom_transform;
}

Vector2 TileMap::_map_to_world(int p_x, int p_y, bool p_ignore_ofs) const {

	Vector2 ret = get_cell_transform().xform(Vector2(p_x, p_y));
	if (!p_ignore_ofs) {
		switch (half_offset) {

			case HALF_OFFSET_X: {
				if (ABS(p_y) & 1) {

					ret += get_cell_transform()[0] * 0.5;
				}
			} break;
			case HALF_OFFSET_Y: {
				if (ABS(p_x) & 1) {
					ret += get_cell_transform()[1] * 0.5;
				}
			} break;
			default: {}
		}
	}
	return ret;
}
Vector2 TileMap::map_to_world(const Vector2 &p_pos, bool p_ignore_ofs) const {

	return _map_to_world(p_pos.x, p_pos.y, p_ignore_ofs);
}
Vector2 TileMap::world_to_map(const Vector2 &p_pos) const {

	Vector2 ret = get_cell_transform().affine_inverse().xform(p_pos);

	switch (half_offset) {

		case HALF_OFFSET_X: {
			if (ret.y > 0 ? int(ret.y) & 1 : (int(ret.y) - 1) & 1) {
				ret.x -= 0.5;
			}
		} break;
		case HALF_OFFSET_Y: {
			if (ret.x > 0 ? int(ret.x) & 1 : (int(ret.x) - 1) & 1) {
				ret.y -= 0.5;
			}
		} break;
		default: {}
	}

	return ret.floor();
}

void TileMap::set_y_sort_mode(bool p_enable) {

	_clear_quadrants();
	y_sort_mode = p_enable;
	VS::get_singleton()->canvas_item_set_sort_children_by_y(get_canvas_item(), y_sort_mode);
	_recreate_quadrants();
	emit_signal("settings_changed");
}

bool TileMap::is_y_sort_mode_enabled() const {

	return y_sort_mode;
}

Array TileMap::get_used_cells() const {

	Array a;
	a.resize(tile_map.size());
	int i = 0;
	for (Map<PosKey, Cell>::Element *E = tile_map.front(); E; E = E->next()) {

		Vector2 p(E->key().x, E->key().y);
		a[i++] = p;
	}

	return a;
}

Array TileMap::get_used_cells_by_id(int p_id) const {

	Array a;
	for (Map<PosKey, Cell>::Element *E = tile_map.front(); E; E = E->next()) {

		if (E->value().id == p_id) {
			Vector2 p(E->key().x, E->key().y);
			a.push_back(p);
		}
	}

	return a;
}

Rect2 TileMap::get_used_rect() { // Not const because of cache

	if (used_size_cache_dirty) {
		if (tile_map.size() > 0) {
			used_size_cache = Rect2(tile_map.front()->key().x, tile_map.front()->key().y, 0, 0);

			for (Map<PosKey, Cell>::Element *E = tile_map.front(); E; E = E->next()) {
				used_size_cache.expand_to(Vector2(E->key().x, E->key().y));
			}

			used_size_cache.size += Vector2(1, 1);
		} else {
			used_size_cache = Rect2();
		}

		used_size_cache_dirty = false;
	}

	return used_size_cache;
}

void TileMap::set_occluder_light_mask(int p_mask) {

	occluder_light_mask = p_mask;
	for (Map<PosKey, Quadrant>::Element *E = quadrant_map.front(); E; E = E->next()) {

		for (Map<PosKey, Quadrant::Occluder>::Element *F = E->get().occluder_instances.front(); F; F = F->next()) {
			VisualServer::get_singleton()->canvas_light_occluder_set_light_mask(F->get().id, occluder_light_mask);
		}
	}
}

int TileMap::get_occluder_light_mask() const {

	return occluder_light_mask;
}

void TileMap::set_light_mask(int p_light_mask) {

	CanvasItem::set_light_mask(p_light_mask);
	for (Map<PosKey, Quadrant>::Element *E = quadrant_map.front(); E; E = E->next()) {

		for (List<RID>::Element *F = E->get().canvas_items.front(); F; F = F->next()) {
			VisualServer::get_singleton()->canvas_item_set_light_mask(F->get(), get_light_mask());
		}
	}
}

void TileMap::set_clip_uv(bool p_enable) {

	if (clip_uv == p_enable)
		return;

	_clear_quadrants();
	clip_uv = p_enable;
	_recreate_quadrants();
}

bool TileMap::get_clip_uv() const {

	return clip_uv;
}

void TileMap::_bind_methods() {

	ClassDB::bind_method(D_METHOD("set_tileset", "tileset"), &TileMap::set_tileset);
	ClassDB::bind_method(D_METHOD("get_tileset"), &TileMap::get_tileset);

	ClassDB::bind_method(D_METHOD("set_mode", "mode"), &TileMap::set_mode);
	ClassDB::bind_method(D_METHOD("get_mode"), &TileMap::get_mode);

	ClassDB::bind_method(D_METHOD("set_half_offset", "half_offset"), &TileMap::set_half_offset);
	ClassDB::bind_method(D_METHOD("get_half_offset"), &TileMap::get_half_offset);

	ClassDB::bind_method(D_METHOD("set_custom_transform", "custom_transform"), &TileMap::set_custom_transform);
	ClassDB::bind_method(D_METHOD("get_custom_transform"), &TileMap::get_custom_transform);

	ClassDB::bind_method(D_METHOD("set_cell_size", "size"), &TileMap::set_cell_size);
	ClassDB::bind_method(D_METHOD("get_cell_size"), &TileMap::get_cell_size);

	ClassDB::bind_method(D_METHOD("_set_old_cell_size", "size"), &TileMap::_set_old_cell_size);
	ClassDB::bind_method(D_METHOD("_get_old_cell_size"), &TileMap::_get_old_cell_size);

	ClassDB::bind_method(D_METHOD("set_quadrant_size", "size"), &TileMap::set_quadrant_size);
	ClassDB::bind_method(D_METHOD("get_quadrant_size"), &TileMap::get_quadrant_size);

	ClassDB::bind_method(D_METHOD("set_tile_origin", "origin"), &TileMap::set_tile_origin);
	ClassDB::bind_method(D_METHOD("get_tile_origin"), &TileMap::get_tile_origin);

	ClassDB::bind_method(D_METHOD("set_center_x", "enable"), &TileMap::set_center_x);
	ClassDB::bind_method(D_METHOD("get_center_x"), &TileMap::get_center_x);

	ClassDB::bind_method(D_METHOD("set_center_y", "enable"), &TileMap::set_center_y);
	ClassDB::bind_method(D_METHOD("get_center_y"), &TileMap::get_center_y);

	ClassDB::bind_method(D_METHOD("set_clip_uv", "enable"), &TileMap::set_clip_uv);
	ClassDB::bind_method(D_METHOD("get_clip_uv"), &TileMap::get_clip_uv);

	ClassDB::bind_method(D_METHOD("set_y_sort_mode", "enable"), &TileMap::set_y_sort_mode);
	ClassDB::bind_method(D_METHOD("is_y_sort_mode_enabled"), &TileMap::is_y_sort_mode_enabled);

	ClassDB::bind_method(D_METHOD("set_collision_use_kinematic", "use_kinematic"), &TileMap::set_collision_use_kinematic);
	ClassDB::bind_method(D_METHOD("get_collision_use_kinematic"), &TileMap::get_collision_use_kinematic);

	ClassDB::bind_method(D_METHOD("set_collision_layer", "layer"), &TileMap::set_collision_layer);
	ClassDB::bind_method(D_METHOD("get_collision_layer"), &TileMap::get_collision_layer);

	ClassDB::bind_method(D_METHOD("set_collision_mask", "mask"), &TileMap::set_collision_mask);
	ClassDB::bind_method(D_METHOD("get_collision_mask"), &TileMap::get_collision_mask);

	ClassDB::bind_method(D_METHOD("set_collision_layer_bit", "bit", "value"), &TileMap::set_collision_layer_bit);
	ClassDB::bind_method(D_METHOD("get_collision_layer_bit", "bit"), &TileMap::get_collision_layer_bit);

	ClassDB::bind_method(D_METHOD("set_collision_mask_bit", "bit", "value"), &TileMap::set_collision_mask_bit);
	ClassDB::bind_method(D_METHOD("get_collision_mask_bit", "bit"), &TileMap::get_collision_mask_bit);

	ClassDB::bind_method(D_METHOD("set_collision_friction", "value"), &TileMap::set_collision_friction);
	ClassDB::bind_method(D_METHOD("get_collision_friction"), &TileMap::get_collision_friction);

	ClassDB::bind_method(D_METHOD("set_collision_bounce", "value"), &TileMap::set_collision_bounce);
	ClassDB::bind_method(D_METHOD("get_collision_bounce"), &TileMap::get_collision_bounce);

	ClassDB::bind_method(D_METHOD("set_occluder_light_mask", "mask"), &TileMap::set_occluder_light_mask);
	ClassDB::bind_method(D_METHOD("get_occluder_light_mask"), &TileMap::get_occluder_light_mask);

	ClassDB::bind_method(D_METHOD("set_cell", "x", "y", "tile", "flip_x", "flip_y", "transpose"), &TileMap::set_cell, DEFVAL(false), DEFVAL(false), DEFVAL(false));
	ClassDB::bind_method(D_METHOD("set_cellv", "position", "tile", "flip_x", "flip_y", "transpose"), &TileMap::set_cellv, DEFVAL(false), DEFVAL(false), DEFVAL(false));
	ClassDB::bind_method(D_METHOD("get_cell", "x", "y"), &TileMap::get_cell);
	ClassDB::bind_method(D_METHOD("get_cellv", "position"), &TileMap::get_cellv);
	ClassDB::bind_method(D_METHOD("is_cell_x_flipped", "x", "y"), &TileMap::is_cell_x_flipped);
	ClassDB::bind_method(D_METHOD("is_cell_y_flipped", "x", "y"), &TileMap::is_cell_y_flipped);
	ClassDB::bind_method(D_METHOD("is_cell_transposed", "x", "y"), &TileMap::is_cell_transposed);

	ClassDB::bind_method(D_METHOD("clear"), &TileMap::clear);

	ClassDB::bind_method(D_METHOD("get_used_cells"), &TileMap::get_used_cells);
	ClassDB::bind_method(D_METHOD("get_used_cells_by_id", "id"), &TileMap::get_used_cells_by_id);
	ClassDB::bind_method(D_METHOD("get_used_rect"), &TileMap::get_used_rect);

	ClassDB::bind_method(D_METHOD("map_to_world", "map_position", "ignore_half_ofs"), &TileMap::map_to_world, DEFVAL(false));
	ClassDB::bind_method(D_METHOD("world_to_map", "world_position"), &TileMap::world_to_map);

	ClassDB::bind_method(D_METHOD("_clear_quadrants"), &TileMap::_clear_quadrants);
	ClassDB::bind_method(D_METHOD("_recreate_quadrants"), &TileMap::_recreate_quadrants);
	ClassDB::bind_method(D_METHOD("_update_dirty_quadrants"), &TileMap::_update_dirty_quadrants);

	ClassDB::bind_method(D_METHOD("_set_tile_data"), &TileMap::_set_tile_data);
	ClassDB::bind_method(D_METHOD("_get_tile_data"), &TileMap::_get_tile_data);

	ADD_PROPERTY(PropertyInfo(Variant::INT, "mode", PROPERTY_HINT_ENUM, "Square,Isometric,Custom"), "set_mode", "get_mode");
	ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "tile_set", PROPERTY_HINT_RESOURCE_TYPE, "TileSet"), "set_tileset", "get_tileset");

	ADD_GROUP("Cell", "cell_");
	ADD_PROPERTY(PropertyInfo(Variant::VECTOR2, "cell_size", PROPERTY_HINT_RANGE, "1,8192,1"), "set_cell_size", "get_cell_size");
	ADD_PROPERTY(PropertyInfo(Variant::INT, "cell_quadrant_size", PROPERTY_HINT_RANGE, "1,128,1"), "set_quadrant_size", "get_quadrant_size");
	ADD_PROPERTY(PropertyInfo(Variant::TRANSFORM2D, "cell_custom_transform"), "set_custom_transform", "get_custom_transform");
	ADD_PROPERTY(PropertyInfo(Variant::INT, "cell_half_offset", PROPERTY_HINT_ENUM, "Offset X,Offset Y,Disabled"), "set_half_offset", "get_half_offset");
	ADD_PROPERTY(PropertyInfo(Variant::INT, "cell_tile_origin", PROPERTY_HINT_ENUM, "Top Left,Center,Bottom Left"), "set_tile_origin", "get_tile_origin");
	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "cell_y_sort"), "set_y_sort_mode", "is_y_sort_mode_enabled");
	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "cell_clip_uv"), "set_clip_uv", "get_clip_uv");

	ADD_GROUP("Collision", "collision_");
	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "collision_use_kinematic", PROPERTY_HINT_NONE, ""), "set_collision_use_kinematic", "get_collision_use_kinematic");
	ADD_PROPERTY(PropertyInfo(Variant::REAL, "collision_friction", PROPERTY_HINT_RANGE, "0,1,0.01"), "set_collision_friction", "get_collision_friction");
	ADD_PROPERTY(PropertyInfo(Variant::REAL, "collision_bounce", PROPERTY_HINT_RANGE, "0,1,0.01"), "set_collision_bounce", "get_collision_bounce");
	ADD_PROPERTY(PropertyInfo(Variant::INT, "collision_layer", PROPERTY_HINT_LAYERS_2D_PHYSICS), "set_collision_layer", "get_collision_layer");
	ADD_PROPERTY(PropertyInfo(Variant::INT, "collision_mask", PROPERTY_HINT_LAYERS_2D_PHYSICS), "set_collision_mask", "get_collision_mask");

	ADD_GROUP("Occluder", "occluder_");
	ADD_PROPERTY(PropertyInfo(Variant::INT, "occluder_light_mask", PROPERTY_HINT_LAYERS_2D_RENDER), "set_occluder_light_mask", "get_occluder_light_mask");
	ADD_GROUP("", "");
	ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "tile_data", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR), "_set_tile_data", "_get_tile_data");

	ADD_SIGNAL(MethodInfo("settings_changed"));

	BIND_CONSTANT(INVALID_CELL);

	BIND_ENUM_CONSTANT(MODE_SQUARE);
	BIND_ENUM_CONSTANT(MODE_ISOMETRIC);
	BIND_ENUM_CONSTANT(MODE_CUSTOM);

	BIND_ENUM_CONSTANT(HALF_OFFSET_X);
	BIND_ENUM_CONSTANT(HALF_OFFSET_Y);
	BIND_ENUM_CONSTANT(HALF_OFFSET_DISABLED);

	BIND_ENUM_CONSTANT(TILE_ORIGIN_TOP_LEFT);
	BIND_ENUM_CONSTANT(TILE_ORIGIN_CENTER);
	BIND_ENUM_CONSTANT(TILE_ORIGIN_BOTTOM_LEFT);
}

TileMap::TileMap() {

	rect_cache_dirty = true;
	used_size_cache_dirty = true;
	pending_update = false;
	quadrant_order_dirty = false;
	quadrant_size = 16;
	cell_size = Size2(64, 64);
	center_x = false;
	center_y = false;
	collision_layer = 1;
	collision_mask = 1;
	friction = 1;
	bounce = 0;
	mode = MODE_SQUARE;
	half_offset = HALF_OFFSET_DISABLED;
	use_kinematic = false;
	navigation = NULL;
	y_sort_mode = false;
	occluder_light_mask = 1;
	clip_uv = false;

	fp_adjust = 0.00001;
	tile_origin = TILE_ORIGIN_TOP_LEFT;
	set_notify_transform(true);
}

TileMap::~TileMap() {

	clear();
}


text:
#ifndef SPECC_UTIL_H_
#define SPECC_UTIL_H_

#include <stdio.h>
#include <unistd.h>

/**
 * Get second
 * @return second
 */
double specc_get_time();

/**
 * Output formatted error message and exit program
 * @param fmt Printf style format string
 */
void specc_internal_error(const char *fmt, ...);

/**
 * Output syntax error message and exit program
 * @param filename File name syntax error has occurred
 * @param line     Line number syntax error has occurred
 * @param fmt      Printf style format string
 */
void specc_syntax_error(const char *filename, int line, const char *fmt, ...);

/**
 * Set of color ID
 */
typedef enum specc_Color {
  specc_DEFAULT_COLOR,
  specc_RED,
  specc_GREEN,
  specc_YELLOW,
  specc_BLUE,
  specc_CYAN
} specc_Color;

/**
 * Formatted print for fp with specifieid indent and color
 * @param fp    Output target
 * @param level indenet level
 * @param color Output color ID (Only when fp points tty)
 * @param fmt   printf style format string
 */
void specc_fcprintf_indented(FILE *fp, specc_Color color, int level, const char *fmt, ...);

/**
 * Almost the same as specc_fcprintf_indented, but to output a newline
 * @param fp    Output target
 * @param level indenet level
 * @param color Output color ID (Only when fp points tty)
 */
#define specc_fcprintfln_indented(fp, color, level, ...)\
  do {\
    specc_fcprintf_indented((fp), (color), (level), __VA_ARGS__);\
    fprintf((fp), "\n");\
  } while (0)

/**
 * Formatted print for fp with specifieid indent and color
 * @param level indenet level
 * @param color Output color ID (Only when fp points tty)
 */
#define specc_cprintf_indented(color, level, ...)\
  specc_fcprintf_indented(stdout, (color), (level), __VA_ARGS__)

/**
 * Almost the same as specc_cprintf_indented, but to output a newline
 * @param level indenet level
 * @param color Output color ID (Only when fp points tty)
 */
#define specc_cprintfln_indented(color, level, ...)\
  specc_fcprintfln_indented(stdout, (color), (level), __VA_ARGS__)

/**
 * Formatted print for stdout with specifieid indent
 * @param level indenet level
 */
#define specc_printf_indented(level, ...)\
  specc_cprintf_indented(specc_DEFAULT_COLOR, level, __VA_ARGS__)

/**
 * Almost the same as specc_printf_indented, but to output a newline
 * @param level indenet level
 * @param color Output color ID (Only when fp points tty)
 */
#define specc_printfln_indented(level, ...)\
  specc_cprintfln_indented(specc_DEFAULT_COLOR, level, __VA_ARGS__)

/**
 * Formatted print for stdout
 */
#define specc_printf(...) specc_printf_indented(0, __VA_ARGS__)

/**
 * Almost the same as specc_printf, but to output a newline
 */
#define specc_printfln(...)\
  specc_printfln_indented(0, __VA_ARGS__)

/**
 * Formatted print for stdout with specifieid color
 * @param color Output color ID
 */
#define specc_cprintf(color, ...)\
  specc_cprintf_indented((color), 0, __VA_ARGS__)

/**
 * Almost the same as specc_cprintf, but to output a newline
 * @param color Output color ID
 */
#define specc_cprintfln(color, ...)\
  specc_cprintfln_indented((color), 0, __VA_ARGS__)

/**
 * Print newline
 */
#define specc_newline() (putchar('\n'))

/**
 * Allocate and format string
 * @param fmt printf style format string
 * @return new string (This string needs to be freed at end)
 */
const char *specc_saprintf(const char *fmt, ...);

/**
 * Return Name of signal number (If not signal number, return NULL)
 * @param  signum Signal number
 * @return        Name of signal or NULL (This string should NOT be freed)
 */
const char *specc_signal_name(int signum);

#endif


text:
  Edit

{{status_upload}}

Sorry, the system does not support the following files

File Name:

Reason:

  <button type="button" class="btn btn-w-m btn-primary photo-area-submit"
          ng-click="uploaderMedia()">Add</button>
  <button type="button" class="btn btn-w-m btn-default"
          ng-click="[cancelMediaUpload(), photoAreaAfterUpload()]">Cancel</button>


text: DCube Labs - Xamarin


text:
<html>
<body>
<applet code=concurrency.invaders.SpaceInvaders.class width="200" height="200" >
</applet>
</body>
</html>