blob_id
stringlengths 40
40
| directory_id
stringlengths 40
40
| path
stringlengths 3
264
| content_id
stringlengths 40
40
| detected_licenses
sequencelengths 0
85
| license_type
stringclasses 2
values | repo_name
stringlengths 5
140
| snapshot_id
stringlengths 40
40
| revision_id
stringlengths 40
40
| branch_name
stringclasses 986
values | visit_date
timestamp[us] | revision_date
timestamp[us] | committer_date
timestamp[us] | github_id
int64 3.89k
681M
⌀ | star_events_count
int64 0
209k
| fork_events_count
int64 0
110k
| gha_license_id
stringclasses 23
values | gha_event_created_at
timestamp[us] | gha_created_at
timestamp[us] | gha_language
stringclasses 145
values | src_encoding
stringclasses 34
values | language
stringclasses 1
value | is_vendor
bool 1
class | is_generated
bool 2
classes | length_bytes
int64 3
10.4M
| extension
stringclasses 122
values | content
stringlengths 3
10.4M
| authors
sequencelengths 1
1
| author_id
stringlengths 0
158
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
04c0dd55bc7dd04c703337be210d6e918813a166 | 85b764c20f5102311da17e85512d13530ef45f39 | /include/MainWindow.h | f5aab043c34e440f11fd2081869ad75a38641be7 | [] | no_license | seafengl/NCCA_ribbons | cef96570760be89cffab89f91638eff293887eb1 | 6dceeeb2c4af7cdbe8f02646abdf77248b2dfd6e | refs/heads/master | 2021-01-17T22:33:27.010080 | 2015-07-21T14:55:51 | 2015-07-21T14:55:51 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,798 | h | #ifndef MAINWINDOW_H
#define MAINWINDOW_H
#include <QtGui/QMainWindow>
#include "GLWindow.h"
//----------------------------------------------------------------------------------------------------------------------
/// @file MainWindow.h
/// @brief This is the MainWindow Class which is generated by the Ui file, if we wish to add anything to the main
/// Ui we add it here
/// @author Jonathan Macey (edited by Peter Matev)
/// @version 1.0
/// @date 10/10/10
/// Revision History :
/// Small changes to key press events.
/// Initial Version 10/10/10 (Binary day ;-0 )
/// @class MainWindow
/// @brief the main re-sizable window which contains a GLWindow widget used to hold our
/// basic gl applications
class MainWindow : public QMainWindow
{
Q_OBJECT
protected :
//----------------------------------------------------------------------------------------------------------------------
/// @brief override the keyPressEvent inherited from QObject so we can handle key presses.
/// @param [in] _event the event to process
//----------------------------------------------------------------------------------------------------------------------
void keyPressEvent(
QKeyEvent *_event
);
//----------------------------------------------------------------------------------------------------------------------
/// @brief override the resizeEvent inherited from QObject so we can handle key presses.
/// @param [in] _event the event to process
//----------------------------------------------------------------------------------------------------------------------
void resizeEvent (
QResizeEvent * _event
);
public:
//----------------------------------------------------------------------------------------------------------------------
/// @brief constructor
/// @param _parent the parent window the for this window
//----------------------------------------------------------------------------------------------------------------------
MainWindow(
QWidget *_parent = 0
);
//----------------------------------------------------------------------------------------------------------------------
/// @brief dtor free up the GLWindow and all resources
//----------------------------------------------------------------------------------------------------------------------
~MainWindow();
private slots :
private:
//----------------------------------------------------------------------------------------------------------------------
/// @brief our gl window created in GLWindow.h
//----------------------------------------------------------------------------------------------------------------------
GLWindow *m_gl;
};
#endif // MAINWINDOW_H
| [
"[email protected]"
] | |
b63abc04939975d7b7d3d4f72de2cfe4757dbeb3 | 313a3a4a2e75ac42787989ae7f4607a340732359 | /LPM1_Test/LPM1_Test.ino | 027c3f24ff39cd8e38a78f85e1ebbdcbe14cd7b2 | [] | no_license | imoralesgt/WSN | 8b1f973e3c92a5ac470f50356cded2132adf0a0c | e2e37751552b9433f5a8bab04e55027188129d94 | refs/heads/master | 2016-09-03T07:17:59.694789 | 2014-11-25T20:30:51 | 2014-11-25T20:31:29 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 752 | ino | #include <RTCplus.h>
#include <Energia.h>
RealTimeClock rtc;
byte now;
void setup(){
pinMode(RED_LED, OUTPUT);
digitalWrite(RED_LED, 0);
pinMode(PUSH2, INPUT_PULLUP);
rtc.begin();
now = rtc.RTC_sec;
}
void dco16MHz(){
BCSCTL1 = CALBC1_16MHZ;
DCOCTL = CALDCO_16MHZ;
}
void dco8MHz(){
BCSCTL1 = CALBC1_8MHZ;
DCOCTL = CALDCO_8MHZ;
}
void dco1MHz(){
BCSCTL1 = CALBC1_1MHZ;
DCOCTL = CALDCO_1MHZ;
}
void loop(){
if(now == rtc.RTC_sec - 5){
dco16MHz();
delay(1);
now = rtc.RTC_sec;
digitalWrite(RED_LED, 1);
delay(2);
digitalWrite(RED_LED, 0);
}
dco1MHz();
__bis_status_register(LPM1_bits);
}
interrupt(TIMER1_A0_VECTOR) Tic_Tac(void){
rtc.Inc_sec();
__bic_status_register(LPM1_bits);
};
| [
"[email protected]"
] | |
7e43e1fb5787f14ff90ef03fe977568336130b28 | ae956d4076e4fc03b632a8c0e987e9ea5ca89f56 | /SDK/TBP_Modifier_SetScoped_parameters.h | 2d775c402caea480d185e57b2277205412fcc4e3 | [] | no_license | BrownBison/Bloodhunt-BASE | 5c79c00917fcd43c4e1932bee3b94e85c89b6bc7 | 8ae1104b748dd4b294609717142404066b6bc1e6 | refs/heads/main | 2023-08-07T12:04:49.234272 | 2021-10-02T15:13:42 | 2021-10-02T15:13:42 | 638,649,990 | 1 | 0 | null | 2023-05-09T20:02:24 | 2023-05-09T20:02:23 | null | UTF-8 | C++ | false | false | 1,588 | h | #pragma once
// Name: bbbbbbbbbbbbbbbbbbbbbbblod, Version: 1
/*!!DEFINE!!*/
/*!!HELPER_DEF!!*/
/*!!HELPER_INC!!*/
#ifdef _MSC_VER
#pragma pack(push, 0x01)
#endif
namespace CG
{
//---------------------------------------------------------------------------
// Parameters
//---------------------------------------------------------------------------
// Function TBP_Modifier_SetScoped.TBP_Modifier_SetScoped_C.OnModEquipped
struct UTBP_Modifier_SetScoped_C_OnModEquipped_Params
{
class UTigerEquippedModModifierValues* Modifiers; // 0x0000(0x0008) (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
};
// Function TBP_Modifier_SetScoped.TBP_Modifier_SetScoped_C.OnModUnequipped
struct UTBP_Modifier_SetScoped_C_OnModUnequipped_Params
{
class UTigerEquippedModModifierValues* Modifiers; // 0x0000(0x0008) (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
};
// Function TBP_Modifier_SetScoped.TBP_Modifier_SetScoped_C.ExecuteUbergraph_TBP_Modifier_SetScoped
struct UTBP_Modifier_SetScoped_C_ExecuteUbergraph_TBP_Modifier_SetScoped_Params
{
int EntryPoint; // 0x0000(0x0004) (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
};
}
#ifdef _MSC_VER
#pragma pack(pop)
#endif
| [
"[email protected]"
] | |
1fa8b47bc8dfa237f159c60641eed90eb20e935f | cd663601e099f4d8a359d6eddbb3e25f0328be09 | /Git_Metroid/Metroidsln/Metroid/manager/ScreenManager.h | 9134b5a83ef08d9c3f38aeb4ebab76ba092df2ab | [] | no_license | vanminhnguyenbmt/Metroid | dacb96f2d0d8d5b2bacb55a131d338516b1eca2c | 450a0d70b977c363aa6194a8f31d3642b0f7e8b3 | refs/heads/master | 2021-08-23T08:55:40.541889 | 2017-12-04T11:32:19 | 2017-12-04T11:32:19 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 302 | h | #pragma once
#include"Screen.h"
class ScreenManager
{
private:
Screen* curScreen;
static ScreenManager* instance;
public:
static ScreenManager* getInstance();
void SetScreen(Screen* screen);
void Update(float time);
void Draw(float time);
void Delete();
ScreenManager();
~ScreenManager();
};
| [
"[email protected]"
] | |
a778ac8df376937c73c8aecaf2bf0e1b0931c2d1 | e982474eb38a5a7c3d783d1236b9c93a7d388c84 | /20130618cppSetMapVector/tvectorjce/tvector.h | 5784f29d6770d26f969f911ea8946690255ba14d | [] | no_license | lj8175/practice | 6e1529c3ac4c4db6b3dd1b99b4ac4bc7d1618206 | f669bf146e6dbf9fc50f24a65b82161904d95434 | refs/heads/master | 2021-01-06T20:38:38.576429 | 2017-04-20T12:46:24 | 2017-04-20T12:46:24 | 11,013,130 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 4,519 | h | // **********************************************************************
// This file was generated by a TAF parser!
// TAF version 3.0.0.20 by WSRD Tencent.
// Generated from `/usr/local/resin_system.mqq.com/webapps/communication/taf/upload/joelliu/tvector.jce'
// **********************************************************************
#ifndef __TVECTOR_H_
#define __TVECTOR_H_
#include <map>
#include <string>
#include <vector>
#include "../jce/Jce.h"
#include "../pdu_header.h"
using namespace std;
struct pdu_protocol_header;
namespace TEST_JEC_VECTOR
{
struct tvec : public taf::JceStructBase
{
public:
static string className()
{
return "TEST_JEC_VECTOR.tvec";
}
static string MD5()
{
return "6f2038bfeafdb7c352c8060ce30b157f";
}
tvec()
{
}
void resetDefautlt()
{
}
template<typename WriterT>
void writeTo(taf::JceOutputStream<WriterT>& _os) const
{
_os.write(ivec, 1);
}
template<typename ReaderT>
void readFrom(taf::JceInputStream<ReaderT>& _is)
{
resetDefautlt();
_is.read(ivec, 1, true);
}
ostream& display(ostream& _os, int _level=0) const
{
taf::JceDisplayer _ds(_os, _level);
_ds.display(ivec,"ivec");
return _os;
}
ostream& displaySimple(ostream& _os, int _level=0) const
{
taf::JceDisplayer _ds(_os, _level);
_ds.displaySimple(ivec, false);
return _os;
}
int Encode(uint8_t * pui_buff, int32_t * pi_buff_len, pdu_protocol_header * pdu_header)
{
try
{
int i_len = pdu_header?*pi_buff_len:0;
int i_ret = 0;
if (pdu_header && (i_ret = ::pdu_header_pack1(pdu_header, pui_buff, (uint32_t *)&i_len)) != 0) { return i_ret; }
taf::JceOutputStream<taf::BufferWriterBuff> os;
os.setBuffer(reinterpret_cast<char *>(pui_buff + i_len), *pi_buff_len - i_len);
this->writeTo(os);
i_len = i_len + static_cast<int>(os.getLength());
if (pdu_header && (i_ret = pdu_header_pack2(pui_buff, (uint32_t *)pi_buff_len, (uint32_t *)&i_len)) != 0) { return i_ret; }
*pi_buff_len = i_len;
}
catch (taf::JceNotEnoughBuff & e)
{
return -100;
}
catch (taf::JceDecodeInvalidValue & e)
{
return -104;
}
catch (...)
{
return -1;
}
return 0;
}
int Decode(uint8_t * pui_buff, int32_t * pi_buff_len, pdu_protocol_header * pdu_header)
{
try
{
int i_ret = 0;
int i_wup_len = pdu_header?*pi_buff_len:0;
int i_end_len = 0;
if (pdu_header && (i_ret = pdu_header_unpack(pui_buff, (uint32_t *)&i_wup_len, pdu_header, (uint32_t *)&i_end_len)) != 0) return i_ret;
taf::JceInputStream<taf::MapBufferReader> is;
is.setBuffer(reinterpret_cast<const char*>(pui_buff + i_wup_len), static_cast<size_t>(*pi_buff_len - i_wup_len - i_end_len));
this->readFrom(is);
}
catch (taf::JceDecodeMismatch & e)
{
return -101;
}
catch (taf::JceDecodeInvalidValue & e)
{
return -104;
}
catch (taf::JceDecodeRequireNotExist & e)
{
return -103;
}
catch (...)
{
return -1;
}
return 0;
}
public:
vector<taf::Int32> ivec;
};
inline bool operator==(const tvec&l, const tvec&r)
{
return l.ivec == r.ivec;
}
inline bool operator!=(const tvec&l, const tvec&r)
{
return !(l == r);
}
int struct_tvec_pack(tvec * pst_struct, uint8_t * pui_buff, int32_t * pi_buff_len, pdu_protocol_header * pdu_header);
int struct_tvec_unpack(uint8_t * pui_buff, int32_t * pi_buff_len, tvec * pst_struct, pdu_protocol_header * pdu_header);
int struct_tvec_unpack(uint8_t * pui_buff, int32_t * pi_buff_len, tvec * pst_struct, pdu_protocol_header * pdu_header, uint8_t * pui_mapbuff, int32_t * pi_mapbuff_len);
}
#endif
| [
"[email protected]"
] | |
a52053ee161ffb4b23205a28b0d3532a3915c714 | c775abdf4d6c6de293b6dff852e4bc6d6ac1861d | /llvm/lib/Target/VE/MCTargetDesc/VEMCTargetDesc.cpp | 3cd09299fc70f4d85f5ab11a6aa95e6c38235251 | [
"NCSA",
"LLVM-exception",
"Apache-2.0"
] | permissive | LevyForchh/llvm-project | d934444c7aed9ca6bf0837efc17af1bab2267aec | 904c0865dfaef343245d6496623f187c4cdc1b61 | refs/heads/apple/master | 2022-04-18T09:33:19.463686 | 2020-04-17T19:45:08 | 2020-04-17T19:45:08 | 256,594,745 | 0 | 0 | Apache-2.0 | 2020-04-17T19:45:10 | 2020-04-17T19:44:40 | null | UTF-8 | C++ | false | false | 3,671 | cpp | //===-- VEMCTargetDesc.cpp - VE Target Descriptions -----------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
//
// This file provides VE specific target descriptions.
//
//===----------------------------------------------------------------------===//
#include "VEMCTargetDesc.h"
#include "VEInstPrinter.h"
#include "VEMCAsmInfo.h"
#include "VETargetStreamer.h"
#include "llvm/MC/MCInstrInfo.h"
#include "llvm/MC/MCRegisterInfo.h"
#include "llvm/MC/MCSubtargetInfo.h"
#include "llvm/Support/ErrorHandling.h"
#include "llvm/Support/TargetRegistry.h"
using namespace llvm;
#define GET_INSTRINFO_MC_DESC
#include "VEGenInstrInfo.inc"
#define GET_SUBTARGETINFO_MC_DESC
#include "VEGenSubtargetInfo.inc"
#define GET_REGINFO_MC_DESC
#include "VEGenRegisterInfo.inc"
static MCAsmInfo *createVEMCAsmInfo(const MCRegisterInfo &MRI, const Triple &TT,
const MCTargetOptions &Options) {
MCAsmInfo *MAI = new VEELFMCAsmInfo(TT);
unsigned Reg = MRI.getDwarfRegNum(VE::SX11, true);
MCCFIInstruction Inst = MCCFIInstruction::createDefCfa(nullptr, Reg, 0);
MAI->addInitialFrameState(Inst);
return MAI;
}
static MCInstrInfo *createVEMCInstrInfo() {
MCInstrInfo *X = new MCInstrInfo();
InitVEMCInstrInfo(X);
return X;
}
static MCRegisterInfo *createVEMCRegisterInfo(const Triple &TT) {
MCRegisterInfo *X = new MCRegisterInfo();
InitVEMCRegisterInfo(X, VE::SX10);
return X;
}
static MCSubtargetInfo *createVEMCSubtargetInfo(const Triple &TT, StringRef CPU,
StringRef FS) {
if (CPU.empty())
CPU = "ve";
return createVEMCSubtargetInfoImpl(TT, CPU, FS);
}
static MCTargetStreamer *
createObjectTargetStreamer(MCStreamer &S, const MCSubtargetInfo &STI) {
return new VETargetELFStreamer(S);
}
static MCTargetStreamer *createTargetAsmStreamer(MCStreamer &S,
formatted_raw_ostream &OS,
MCInstPrinter *InstPrint,
bool isVerboseAsm) {
return new VETargetAsmStreamer(S, OS);
}
static MCInstPrinter *createVEMCInstPrinter(const Triple &T,
unsigned SyntaxVariant,
const MCAsmInfo &MAI,
const MCInstrInfo &MII,
const MCRegisterInfo &MRI) {
return new VEInstPrinter(MAI, MII, MRI);
}
extern "C" void LLVMInitializeVETargetMC() {
// Register the MC asm info.
RegisterMCAsmInfoFn X(getTheVETarget(), createVEMCAsmInfo);
for (Target *T : {&getTheVETarget()}) {
// Register the MC instruction info.
TargetRegistry::RegisterMCInstrInfo(*T, createVEMCInstrInfo);
// Register the MC register info.
TargetRegistry::RegisterMCRegInfo(*T, createVEMCRegisterInfo);
// Register the MC subtarget info.
TargetRegistry::RegisterMCSubtargetInfo(*T, createVEMCSubtargetInfo);
// Register the object target streamer.
TargetRegistry::RegisterObjectTargetStreamer(*T,
createObjectTargetStreamer);
// Register the asm streamer.
TargetRegistry::RegisterAsmTargetStreamer(*T, createTargetAsmStreamer);
// Register the MCInstPrinter
TargetRegistry::RegisterMCInstPrinter(*T, createVEMCInstPrinter);
}
}
| [
"[email protected]"
] | |
880ae7f9d34692717ac5d680581b01768ca28aea | 40dd73e1392e722f0f4e2122eed65da2a5aebadd | /Account.cpp | cde14335748917b5b0db911766f07df12688e2c5 | [] | no_license | manojmula/Cpp | ddf239e576747e68ba50339c8b2e27dffeae1e61 | 44c0c4ff1bbd300692cb9d87c8728768e205923a | refs/heads/master | 2023-02-09T07:35:07.169007 | 2020-12-28T10:13:17 | 2020-12-28T10:13:17 | 283,914,927 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 372 | cpp | #include "Account.h"
void Account :: set_name(std::string n)
{
name = n;
}
std::string Account :: get_name()
{
return name;
}
bool Account :: deposit(double amount)
{
balance += amount;
return true;
}
bool Account :: withdraw(double amount)
{
if(balance-amount>0)
{
balance-=amount;
return true;
}
else return false;
} | [
"[email protected]"
] | |
03b0c15e6545fc7be9fe786ed9fcfc4cb25ed94c | dfe27edbf0c891bf8ddab66e1cbee97e98b3011b | /RenderSystems/GLSupport/include/GLSL/OgreGLSLProgramManagerCommon.h | a61206c3e4adad63613001c77e6a90267f6488ac | [
"MIT"
] | permissive | puqing/ogre | 37cbbfd718096367baca73960c255462e2bc88b1 | 55d05cb54e367e76e69f8361c6d3305cfa9d5109 | refs/heads/master | 2020-12-02T13:26:53.039078 | 2019-12-30T01:02:01 | 2019-12-30T11:35:03 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 4,233 | h | /*
-----------------------------------------------------------------------------
This source file is part of OGRE
(Object-oriented Graphics Rendering Engine)
For the latest info, see http://www.ogre3d.org/
Copyright (c) 2000-2014 Torus Knot Software Ltd
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.
-----------------------------------------------------------------------------
*/
#ifndef __GLSLProgramManagerCommon_H__
#define __GLSLProgramManagerCommon_H__
#include "OgreGLSupportPrerequisites.h"
#include "OgreString.h"
#include "OgreGpuProgramParams.h"
#include "OgreGLSLProgramCommon.h"
namespace Ogre {
class GLSLShaderCommon;
/** Ogre assumes that there are separate programs to deal with but
GLSL has one program object that represents the active shader
objects during a rendering state. GLSL shader objects are
compiled separately and then attached to a program object and
then the program object is linked. Since Ogre can only handle
one program being active in a pass, the GLSL Link Program
Manager does the same. The GLSL Link program manager acts as
a state machine and activates a program object based on the
active programs. Previously created program objects are
stored along with a unique key in a hash_map for quick
retrieval the next time the program object is required.
*/
class GLSLProgramManagerCommon
{
protected:
typedef std::map<String, uint32> StringToEnumMap;
StringToEnumMap mTypeEnumMap;
/** Convert GL uniform size and type to OGRE constant types
and associate uniform definitions together. */
virtual void convertGLUniformtoOgreType(uint32 gltype,
GpuConstantDefinition& defToUpdate) = 0;
/** Parse an individual uniform from a GLSL source file and
store it in a GpuNamedConstant. */
void parseGLSLUniform(
String line, GpuNamedConstants& defs,
const String& filename, const GpuSharedParametersPtr& sharedParams);
typedef std::map<uint32, GLSLProgramCommon*> ProgramMap;
typedef ProgramMap::iterator ProgramIterator;
/// container holding previously created program objects
ProgramMap mPrograms;
/// Active shader objects defining the active program object.
GLShaderList mActiveShader;
public:
virtual ~GLSLProgramManagerCommon();
/** Populate a list of uniforms based on GLSL source and store
them in GpuNamedConstants.
@param src Reference to the source code.
@param constantDefs The defs to populate (will
not be cleared before adding, clear it yourself before
calling this if that's what you want).
@param filename The file name this came from, for logging errors.
*/
void extractUniformsFromGLSL(
const String& src, GpuNamedConstants& constantDefs, const String& filename);
/// Destroy all programs which referencing this shader
void destroyAllByShader(GLSLShaderCommon* shader);
};
}
#endif // __GLSLProgramManagerCommon_H__
| [
"[email protected]"
] | |
e34e42a9b3ba01d8f4e1c0901538a1057ebb5b71 | 6e87882e55d08fe94fc6b85c1f5b062bd149f64e | /src/test/cpp/TestImageFactory.hpp | c23ba373e7f4d0f869d510991d141323d1efa4b6 | [] | no_license | jvff/mestrado-implementacao | 1033a490860977a8ffb0bdfe648564f53e3cbabf | 47fb47495112d30940328e7e55cf7e7efba903a9 | refs/heads/master | 2020-12-29T01:54:06.142023 | 2016-07-03T01:11:37 | 2016-07-07T15:30:27 | 42,725,607 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,513 | hpp | #ifndef TEST_IMAGE_FACTORY_HPP
#define TEST_IMAGE_FACTORY_HPP
#include <vector>
#include <CL/cl.hpp>
#include "OpenCLImage.hpp"
#include "Image.hpp"
template <typename ImageType>
class TestImageFactory {
public:
ImageType createImage(unsigned int width, unsigned int height) {
return ImageType(width, height);
}
};
template <typename PixelType>
class TestImageFactory<OpenCLImage<PixelType> > {
private:
using ImageType = OpenCLImage<PixelType>;
cl::Context context;
cl::CommandQueue commandQueue;
public:
TestImageFactory() {
auto devices = getGpuDevices();
createContext(devices);
createCommandQueue(devices[0]);
}
ImageType createImage(unsigned int width, unsigned int height) {
return ImageType(width, height, context, commandQueue);
}
private:
std::vector<cl::Device> getGpuDevices() {
std::vector<cl::Device> devices;
auto platforms = getPlatforms();
auto firstPlatform = platforms[0];
firstPlatform.getDevices(CL_DEVICE_TYPE_GPU, &devices);
return devices;
}
std::vector<cl::Platform> getPlatforms() {
std::vector<cl::Platform> platforms;
cl::Platform::get(&platforms);
return platforms;
}
void createContext(const std::vector<cl::Device>& devices) {
context = cl::Context(devices);
}
void createCommandQueue(const cl::Device& device) {
commandQueue = cl::CommandQueue(context, device);
}
};
#endif
| [
"[email protected]"
] | |
c74e3d1ac7d6afda90ab1642f0269ce3751d70a3 | 2e939da6db6f24404c223f13ccf5c1d8e1be4956 | /ZJU数据结构/2-4.cpp | cc0766828fe679ca9ce182df4d401b4c12d7ce1a | [] | no_license | whitebluepants/OJ-Practice | ffc793950491b76b3b703c826fce95e9a07b1ddf | f32e7afe3e2c347eca5620ff4e241614805c4555 | refs/heads/master | 2021-07-18T13:42:27.971732 | 2019-01-11T02:45:38 | 2019-01-11T02:45:38 | 121,104,040 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,484 | cpp | #include <stack>
#include <stdio.h>
using namespace std;
int read()
{
char ch = getchar();
int f = 1;
int x = 0;
while(ch < '0' || ch > '9'){if(ch == '-')f = 0;ch = getchar();}
while(ch >= '0' && ch <= '9'){x = x * 10 + ch - '0';ch = getchar();}
return f?x:x*-1;
}
int main()
{
int m = read(),n = read(),k = read();
for(int i = 0;i < k;i ++)
{
int num[1001] = {};
for(int i = 0;i < n;i ++)
{
num[i] = read();
}
int flag = 0;
stack<int> s;
int in[1001] = {};
for(int i = 0;i < n;i ++)
{
int t = num[i];
if(in[t])
{
int temp = s.top();
s.pop();
if(temp != t)
{
flag = 1;
break;
}
}
else
{
for(int i = 1;i <= t;i ++)
{
if(!in[i])
{
in[i] = 1;
s.push(i);
}
}
if(s.size() > m)
{
flag = 1;
break;
}
int temp = s.top();
s.pop();
}
}
if(flag)
{
printf("NO\n");
}
else
{
printf("YES\n");
}
}
return 0;
} | [
"[email protected]"
] | |
3f809eca4ddf961612402effac3a0fa100e5c6d7 | 333ded842bfbefe029583cf6a7723160af682995 | /include/TDigitizer.hpp | 9d1b4cc91171b44873961078568e4969b3348621 | [] | no_license | aogaki/Polarimeter | 79da12ac93df28e9d8221402183f236f46b5de84 | 41e544b5481c7e51fa31c433434912a0a07c0238 | refs/heads/master | 2020-06-18T14:01:07.919715 | 2019-08-06T11:26:24 | 2019-08-06T11:26:24 | 196,326,412 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,899 | hpp | #ifndef TDigitizer_hpp
#define TDigitizer_hpp 1
// For the standard fiemware digitizer
// This will be super class of other firmware and model family
#include <string>
#include <vector>
#include <CAENDigitizer.h>
#include <CAENDigitizerType.h>
enum class FirmWareCode {
// I need only theese
// Its are not same as CAENDigitizerType.h
DPP_PSD,
DPP_PHA,
DPP_CI,
STD,
};
class TDigitizer
{
public:
TDigitizer();
virtual ~TDigitizer();
void SendSWTrigger();
void BoardCalibration();
virtual void Initialize() = 0;
virtual void ReadEvents() = 0;
// When the FW is expired. Configuration can be done.
// But, StartAcquisition can not be done.
virtual CAEN_DGTZ_ErrorCode StartAcquisition() = 0;
virtual void StopAcquisition() = 0;
virtual uint32_t GetNEvents() = 0;
unsigned char *GetDataArray() { return fDataArray; };
void SetModNumber(unsigned char n) { fModNumber = n; };
protected:
int fHandler;
unsigned char fModNumber;
void Open(CAEN_DGTZ_ConnectionType type, int link, int node, uint32_t VMEadd);
void Close();
void Reset();
// For board information
void GetBoardInfo();
int fDigitizerModel;
FirmWareCode fFirmware;
uint32_t fNChs;
int fTSample; // This means time step length in ns
int fNBits; // ADC, Waveform resolution
void PrintError(const CAEN_DGTZ_ErrorCode &err, const std::string &funcName);
uint32_t fNEvents;
unsigned char *fDataArray;
CAEN_DGTZ_ErrorCode RegisterSetBits(uint16_t addr, int start_bit, int end_bit,
int val);
private:
// Those SPI register functions are copy from digiTES
CAEN_DGTZ_ErrorCode ReadSPIRegister(uint32_t ch, uint32_t address,
uint32_t &data);
CAEN_DGTZ_ErrorCode WriteSPIRegister(uint32_t ch, uint32_t address,
uint32_t data);
};
#endif
| [
"[email protected]"
] | |
e6ad199f4b16b86605eb7d43c4874351c2c74e8d | 303b8d3e45f5e07749e775a1ae762b81acfcce4c | /BShip/Point.h | 639b45774bed3a581a393ea086cb24904bb97856 | [] | no_license | aldidoanta/battleship | f21d589faede7b09907da0de9f8333faa6c161f0 | 456883654c85aff3950e28ba886a831268d868aa | refs/heads/master | 2021-01-19T07:49:16.492682 | 2013-08-27T06:57:01 | 2013-08-27T06:57:01 | 12,399,401 | 1 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 877 | h | //File : Point.h
#ifndef GPOINT_H
#define GPOINT_H
class Point
{
private:
//data member
int X;
int Y;
public:
//constructor
//default
Point ();
//user-defined
Point (int,int);
//copy constructor
Point(const Point&);
//destructor
~Point();
//operator=
Point& operator= (const Point&);
//GET and SET
int GetAbsis();
int GetOrdinat();
void SetAbsis(int);
void SetOrdinat(int);
//Relational
int IsEqual(Point P) const;
int LT (Point P1, Point P2) const;
/* menghasilkan true jika P1 < P2 : absis dan ordinat lebih kecil */
int Operator (Point P1) const;
/* menghasilkan true jika P1 < Current_Object : absis dan ordinat lebih kecil */
//predikat lain
int IsOrigin() const;
/* menghasilkan true jika Current_Object berada pada (0,0), selain itu false. */
//function member
void Mirror ();
Point MirrorOf();
void PrintObj();
};
#endif
| [
"[email protected]"
] | |
5b1c4206825c8462e2a4499cf16e6f493df85c07 | 3101aa54a55f252698608c4a6d5bb76439fdb35c | /text.cpp | 99d01aedb5cebdcec2b57eda3ec4279f0a887b13 | [] | no_license | zygoloid/redline | 0c42d27ec517bd71b6e054b7081c77ad9c7b60ef | 9dc9a0951fb3389e06a901c1dda1dd25069e4407 | refs/heads/master | 2022-11-22T09:26:06.719153 | 2020-07-27T06:13:10 | 2020-07-27T06:13:10 | 282,809,792 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 8,697 | cpp | #include "redline/text.hpp"
#include <vector>
#include <iostream>
using namespace Redline;
namespace
{
int Clamp(int x, int min, int max)
{
return (x < min ? min : x > max ? max : x);
}
}
class Cursor::Internals
{
public:
//! Construct root node.
Internals() : refcount(0), text(), prev(this), next(this), line(), column() {}
Internals(const Text *_text, int _line, int _column, Internals *_after) :
refcount(0), text(_text), prev(_after), next(_after->next), line(_line), column(_column)
{
prev->next = next->prev = this;
}
~Internals()
{
prev->next = next;
next->prev = prev;
}
static Internals *IncRef(Internals *p)
{
if (p)
{
++p->refcount;
}
return p;
}
static void DecRef(Internals *p)
{
if (p && --p->refcount == 0)
{
delete p;
}
}
Internals *Next() const { return next; }
Internals *Move(int x, int y)
{
// Do nothing if trying to go off top/bottom.
int l = Clamp(line + y, 0, text->GetNumLines() - 1);
// Wrap around if asked to go off left or right edge.
int c = column + x;
while (x && c < 0 && l)
{
--l;
c += text->Get(l).size() + 1;
}
while (x && c > static_cast<int>(text->Get(l).size()) && l < text->GetNumLines() - 1)
{
c -= text->Get(l).size() + 1;
++l;
}
c = Clamp(c, 0, text->Get(l).size());
return new Internals(text, l, c, this);
}
private:
int refcount;
public:
const Text *text;
private:
Internals *prev, *next;
public:
int line, column;
};
Cursor::Cursor() : internals() {}
Cursor::Cursor(const Cursor &o) : internals(Internals::IncRef(o.internals)) {}
Cursor::Cursor(Internals *p) : internals(Internals::IncRef(p)) {}
Cursor &Cursor::operator=(const Cursor &o)
{
Internals *p = Internals::IncRef(o.internals);
Internals::DecRef(internals);
internals = p;
return *this;
}
Cursor::~Cursor() { Internals::DecRef(internals); }
bool Cursor::IsValid() const { return internals; }
const Text *Cursor::GetText() const { return internals ? internals->text : 0; }
int Cursor::GetLine() const { return internals ? internals->line : 0; }
int Cursor::GetColumn() const { return internals ? internals->column : 0; }
Cursor Cursor::Move(int x, int y) const { return internals ? internals->Move(x, y) : 0; }
int Cursor::Cmp(const Cursor &o) const
{
return IsValid() != o.IsValid() ? IsValid() - o.IsValid() :
GetLine() != o.GetLine() ? GetLine() - o.GetLine() :
GetColumn() - o.GetColumn();
}
//--------------------------------------------------------------------------------------------------
/*! Get the character to the left of the cursor, if any, or 0 if not (if, for instance, the cursor
* is at the start of the text, or is invalid).
*/
//--------------------------------------------------------------------------------------------------
char Cursor::GetLeft() const
{
if (const Text *text = GetText())
{
std::string t = text->Get(*this, Move(-1, 0));
if (t.size())
{
return t[0];
}
}
return 0;
}
//--------------------------------------------------------------------------------------------------
/*! Get the character to the right of the cursor, if any, or 0 if not (if, for instance, the cursor
* is at the end of the text, or is invalid).
*/
//--------------------------------------------------------------------------------------------------
char Cursor::GetRight() const
{
if (const Text *text = GetText())
{
std::string t = text->Get(*this, Move(1, 0));
if (t.size())
{
return t[0];
}
}
return 0;
}
//--------------------------------------------------------------------------------------------------
/*! Implementation of block of text.
*/
//--------------------------------------------------------------------------------------------------
class Text::Internals
{
public:
Internals(Editor &_editor) :
editor(_editor), text(1)
{
}
Editor &editor;
std::vector<std::string> text;
Cursor::Internals cursorList;
};
Text::Text(Editor &editor) :
internals(new Internals(editor))
{
}
Text::~Text()
{
delete internals;
}
int Text::GetNumLines() const
{
return internals->text.size();
}
std::string Text::Get() const
{
std::string text;
for (size_t n = 0; n < internals->text.size(); ++n)
{
if (n) { text += '\n'; }
text += internals->text[n];
}
return text;
}
std::string Text::Get(int line) const
{
return internals->text[line];
}
std::string Text::Get(const Cursor &from, const Cursor &to) const
{
std::string result;
if (from.GetText() == this && to.GetText() == this)
{
int startLine = from.internals->line, endLine = to.internals->line;
int start = from.internals->column, end = to.internals->column;
if (to < from)
{
std::swap(startLine, endLine);
std::swap(start, end);
}
for (int line = startLine; line <= endLine; ++line)
{
const std::string &text = internals->text[line];
int startThisLine = (line == startLine ? start : 0);
int endThisLine = (line == endLine ? end : text.size());
result += text.substr(startThisLine, endThisLine - startThisLine);
if (line != endLine)
{
result += '\n';
}
}
}
return result;
}
Cursor Text::Begin(int line) const
{
if (line >= GetNumLines()) { return End(); }
line = std::max(line, 0);
return new Cursor::Internals(this, line, 0, &internals->cursorList);
}
Cursor Text::End(int line) const
{
if (line < 0) { return Begin(); }
line = std::min(line, GetNumLines() - 1);
return new Cursor::Internals(this, line, internals->text[line].size(), &internals->cursorList);
}
Cursor Text::Begin() const
{
return Begin(0);
}
Cursor Text::End() const
{
return End(GetNumLines() - 1);
}
void Text::Insert(InsertPosition rel, const Cursor &pos, const std::string &text)
{
if (pos.GetText() == this)
{
int line = pos.internals->line;
int column = pos.internals->column;
std::string restOfLine = internals->text[line].substr(column);
internals->text[line].erase(column);
int currLine = line;
// Scan over chunks of the string separated by newlines.
for (int textPos = 0; textPos <= text.size(); ++currLine)
{
int textEnd = std::min(text.find('\n', textPos), text.size());
std::string addThisLine = text.substr(textPos, textEnd - textPos);
if (currLine == line)
{
// First line. Append bits.
internals->text[currLine].insert(column, addThisLine);
}
else
{
// Second or subsequent lines: insert a new line.
internals->text.insert(internals->text.begin() + currLine, addThisLine);
}
textPos = textEnd + 1;
}
// Add back on the end of the line into which we were inserting.
internals->text[currLine - 1] += restOfLine;
int addedLines = currLine - line - 1;
// Adjustment to column of cursor after pos on the same line.
int deltaLastLine = (addedLines ? text.size() - text.rfind('\n') - column - 1: text.size());
for (Cursor::Internals *c = internals->cursorList.Next(); c != &internals->cursorList; c = c->Next())
{
if (c->line == line && c->column >= column + rel)
{
c->line += addedLines;
c->column += deltaLastLine;
}
else if (c->line > line)
{
c->line += addedLines;
}
}
}
}
void Text::Delete(const Cursor &from, const Cursor &to)
{
if (from.GetText() == this && to.GetText() == this)
{
int startLine = from.internals->line, endLine = to.internals->line;
int start = from.internals->column, end = to.internals->column;
if (to < from)
{
std::swap(startLine, endLine);
std::swap(start, end);
}
internals->text[startLine] = internals->text[startLine].substr(0, start) + internals->text[endLine].substr(end);
internals->text.erase(internals->text.begin() + startLine + 1, internals->text.begin() + endLine + 1);
for (Cursor::Internals *c = internals->cursorList.Next(); c != &internals->cursorList; c = c->Next())
{
if (c->line > startLine || (c->line == startLine && c->column > start))
{
if (c->line < endLine || (c->line == endLine && c->column < end))
{
// In the deleted area.
c->line = startLine;
c->column = start;
}
else if (c->line == endLine)
{
// After the deleted area on the end line.
c->line = startLine;
c->column -= end - start;
}
else
{
// On a line below the deleted area.
c->line -= endLine - startLine;
}
}
}
}
}
| [
"[email protected]"
] | |
96f8b866cf68eaaced89eb280a04d605ded9385f | 30cac0475e3a60ab413e018f788c6cd795118f85 | /src/Message.cpp | f950aec6c18787af8a87e44b8397f0ea4cfd465a | [
"MIT"
] | permissive | matheuscscp/process-scheduler | 79b846dc3e625fda643c006ceb9775f46c8fd28a | f10d96602b9e1d6747e082bf2c8871fb3fee3c98 | refs/heads/master | 2020-12-11T02:04:12.464515 | 2014-11-19T12:35:43 | 2014-11-19T12:35:43 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 216 | cpp | /*
* Message.cpp
*
* Created on: Sep 11, 2014
* Author: matheus
*/
#include "Message.hpp"
#include <cstring>
Message::Message(long type) : type(type) {
memset(&(this->content), 0, sizeof(Content));
}
| [
"[email protected]"
] | |
56792b753c8dd078022a6346c2092d627f3b3e9e | 203e602370f4673f65f3c3022355ff6634c268ac | /c/hdu/difficult/hdu1011Dp应用.cpp | 2c608416a19ecc9d6bec780f00044bfaf7fb8f0d | [
"Apache-2.0"
] | permissive | WeAreChampion/notes | 4942fbd5c238559eb318787adc27be72f848de44 | 6c0f726d1003e5083d9cf1b75ac6905dc1c19c07 | refs/heads/master | 2020-06-14T03:54:00.587873 | 2016-12-07T13:02:45 | 2016-12-07T13:02:45 | 75,520,188 | 2 | 0 | null | null | null | null | GB18030 | C++ | false | false | 2,412 | cpp | /*
貌似是很经典的树形dp问题，应该说是树形dp的入门！！
感觉树形dp比背包多了一个辅助数组，背包直接一个数组循环下去，
而树形dp因为有分支，不是线性的，所以就需要用一个辅助数组来进行转化最优情况！
1011 题目大意：一棵树，有n个结点，每个结点有v个bug，有w的brain。
我从1号结点开始走，带着m个战士。
1个战士可以消灭20个bugs，如果我把某个结点的所有bug都消灭了我就能得到那个结点的brain。
如果想攻击当前结点，那么必须先攻击了它的父结点（1号点除外）。
其中当你攻占了当前结点，你可以分派人手，走向几个不同的子结点，
去攻占更多。也就是说，不是单一的路径。
*/
# include<stdio.h>
# include<string.h>
# define N 105
struct node{
int from,to,next;
}edge[2*N];
int head[N],tol,visit[N],ans[N],bug[N],n,m,dp[N][N],f[N][N];
void add(int a,int b)
{
edge[tol].from=a;
edge[tol].to=b;
edge[tol].next=head[a];
head[a]=tol++;
}
int max(int a,int b)//get max
{
return a>b?a:b;
}
void dfs(int u)
{
int i,j,r,tt,k;
visit[u]=1;//mark is visited
for(i=head[u];i!=-1;i=edge[i].next)
{
r=edge[i].to;
if(!visit[r])//not visited
{
dfs(r);
for(k=m;k>=1;k--)
{
for(j=1;j<=k;j++)
{
f[u][k]=max(f[u][k],f[u][k-j]+dp[r][j]);//get max
}
}
/*for(j=0;j<=m;j++)
{
if(j*20>=ans[u])
dp[u][j]=max(dp[u][j],dp[r][(j*20-ans[u])/20]+bug[u]);
}*/
}
}
tt=(ans[u]+19)/20;
for(j=tt;j<=m;j++)
dp[u][j]=f[u][j-tt]+bug[u];
}
int main()
{
int i,a,b;
while(scanf("%d%d",&n,&m)!=EOF)
{
if(n==-1 && m==-1) break;
for(i=1;i<=n;i++)
scanf("%d%d",&ans[i],&bug[i]);
tol=0;//init
memset(head,-1,sizeof(head));
for(i=1;i<n;i++)
{
scanf("%d%d",&a,&b);
add(a,b);
add(b,a);
}
memset(visit,0,sizeof(visit));//init
memset(dp,0,sizeof(dp));
memset(f,0,sizeof(f));
if(m==0)
{
printf("0\n");
continue;
}
dfs(1);
printf("%d\n",dp[1][m]);
}
return 0;
}
/*
Input:
5 10
50 10
40 10
40 20
65 30
70 30
1 2
1 3
2 4
2 5
1 1
20 7
-1 -1
output:
50
7
*/ | [
"[email protected]"
] | |
dc102640d70b555941ca0a80417c98ded39794f0 | 4d01275d7c1d606b0a7762f1545d7fa9a439524f | /Dallas.h | de07dada3e3a00301e6bfe712614ee13884e3468 | [] | no_license | mupimenov/hcontroller | ae187ae111f4e9fdb163e914a40ed0f7942f6f17 | 8c39ad652b12ed124e905fe15f7dee54f688ed95 | refs/heads/master | 2020-04-06T03:53:42.029333 | 2016-07-31T05:56:40 | 2016-07-31T05:56:40 | 58,383,609 | 0 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 278 | h | /*
* Dallas.h
*
* Created on: May 20, 2016
* Author: mupimenov
*/
#ifndef DALLAS_H_
#define DALLAS_H_
#include "OneWire.h"
class Dallas {
public:
Dallas(uint8_t pin);
virtual ~Dallas();
float getTemperature();
private:
OneWire ds;
};
#endif /* DALLAS_H_ */
| [
"[email protected]"
] | |
8849a2c6547491f2f81821cc42714dcbf6b5e318 | 462353333f5fc8f13e12db89720d8668a96e3639 | /ftc265-lib/src/main/cpp/Eigen/LU | f5304865437cc0814479b0342f97877543644bd3 | [] | no_license | mcm001/android-aruco | c397fdd786bd87945a21aeb82170e4782a7ad3f7 | 522f262a81736ce034ae993ff66332cf24693b7b | refs/heads/master | 2023-03-27T08:31:26.984086 | 2021-03-10T19:40:37 | 2021-03-10T19:40:37 | 346,417,421 | 0 | 1 | null | 2021-03-14T16:10:57 | 2021-03-10T16:18:55 | C++ | UTF-8 | C++ | false | false | 1,433 | // This file is part of Eigen, a lightweight C++ template library
// for linear algebra.
//
// This Source Code Form is subject to the terms of the Mozilla
// Public License v. 2.0. If a copy of the MPL was not distributed
// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
#ifndef EIGEN_LU_MODULE_H
#define EIGEN_LU_MODULE_H
#include "Core"
#include "src/Core/util/DisableStupidWarnings.h"
/** \defgroup LU_Module LU module
* This module includes %LU decomposition and related notions such as matrix inversion and determinant.
* This module defines the following MatrixBase methods:
* - MatrixBase::inverse()
* - MatrixBase::determinant()
*
* \code
* #include <Eigen/LU>
* \endcode
*/
#include "src/misc/Kernel.h"
#include "src/misc/Image.h"
#include "src/LU/FullPivLU.h"
#include "src/LU/PartialPivLU.h"
#ifdef EIGEN_USE_LAPACKE
#ifdef EIGEN_USE_MKL
#include "mkl_lapacke.h"
#else
#include "src/misc/lapacke.h"
#endif
#include "src/LU/PartialPivLU_LAPACKE.h"
#endif
#include "src/LU/Determinant.h"
#include "src/LU/InverseImpl.h"
// Use the SSE optimized version whenever possible. At the moment the
// SSE version doesn't compile when AVX is enabled
#if defined EIGEN_VECTORIZE_SSE && !defined EIGEN_VECTORIZE_AVX
#include "src/LU/arch/Inverse_SSE.h"
#endif
#include "src/Core/util/ReenableStupidWarnings.h"
#endif // EIGEN_LU_MODULE_H
/* vim: set filetype=cpp et sw=2 ts=2 ai: */
| [
"[email protected]"
] | ||
bfc00a6a293566b7f8ab3768f83e4a74905487c3 | 9e659d8913d042a7ecb77db5d566cea264f342fb | /Faisal Sir Assignment/Week 06/190041222_task3.cpp | d0741da12101d08bbcbbe55510705850567fd2c3 | [] | no_license | alinmdsifayet/190041222-CSE-4302 | f82c3bd679cd5ae1708bcbf7968956b97f33ed0d | cb80b993f8b222883679ad95d5d07b266f4f570b | refs/heads/main | 2023-07-15T03:16:36.552357 | 2021-08-27T08:11:44 | 2021-08-27T08:11:44 | 383,528,822 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,241 | cpp | #include<bits/stdc++.h>
using namespace std;
class FloatNumber
{
private:
float number;
public:
FloatNumber(): number(0)
{}
FloatNumber(float key): number(key)
{}
void operator =(float key)
{
number=key;
}
void display()
{
cout<<number;
}
FloatNumber operator+(const FloatNumber &right) const
{
return FloatNumber(number+right.number);
}
FloatNumber operator- (const FloatNumber &right) const
{
return FloatNumber(number-right.number);
}
FloatNumber operator/ (const FloatNumber &right) const
{
return FloatNumber(number/right.number);
}
FloatNumber operator* (const FloatNumber &right) const
{
return FloatNumber(number*right.number);
}
};
int main()
{
FloatNumber f1,f2,f3,f4;
f1=8.6;
f2=10.4;
f3=f1+f2;
f4=f1-f2;
cout<<"f1+f2="; f3.display(); cout<<"\n";
cout<<"f1-f2= "; f4.display();cout<<"\n";
f3=f1/f2;
f4=f1*f2;
cout<<"f1/f2="; f3.display();cout<<"\n";
cout<<"f1*f2= "; f4.display();cout<<"\n";
}
| [
"[email protected]"
] | |
e8d040764c6e82528475b426529085e8e7fc487a | 7a176787beb563874074c6dc61f00ab4a59f9839 | /vldx11/vldx11/ObjectUniform.cpp | a11d12a0d9e0d7fb5808eb9bbafd52a28a40d93d | [] | no_license | ACskyline/VLD3D11 | 7edb4379a2300be739d974024851095e0a572969 | 8fb4e4abf26363a2c82d0154cdd9c96a4397fb7d | refs/heads/master | 2021-06-27T11:21:45.705534 | 2019-06-16T00:22:13 | 2019-06-16T00:22:13 | 143,146,051 | 5 | 2 | null | null | null | null | UTF-8 | C++ | false | false | 2,709 | cpp | #include "ObjectUniform.h"
ObjectUniform::ObjectUniform() : objectUniformBuffer(nullptr), needToUpload(false)
{
}
ObjectUniform::~ObjectUniform()
{
if (objectUniformBuffer != nullptr) objectUniformBuffer->Release();
}
bool ObjectUniform::CreateBuffer(ID3D11Device* d3d11Device)
{
HRESULT hr;
//PerObject Constant Buffer Start
D3D11_BUFFER_DESC objectBufferDesc;
ZeroMemory(&objectBufferDesc, sizeof(D3D11_BUFFER_DESC));
objectBufferDesc.Usage = D3D11_USAGE_DEFAULT;
objectBufferDesc.ByteWidth = sizeof(ObjectUniformData);
objectBufferDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
objectBufferDesc.CPUAccessFlags = 0;
objectBufferDesc.MiscFlags = 0;
hr = d3d11Device->CreateBuffer(&objectBufferDesc, NULL, &objectUniformBuffer);
if (!CheckError(hr, nullptr)) return false;
//PerObject Constant Buffer Finish
return true;
}
void ObjectUniform::ObjectUniformBufferData(ID3D11DeviceContext* d3d11DevCon)
{
d3d11DevCon->UpdateSubresource(objectUniformBuffer, 0, NULL, &objectUniformData, 0, 0);
needToUpload = false;
}
void ObjectUniform::SetObjectUniformBufferVS(ID3D11DeviceContext* d3d11DevCon)
{
d3d11DevCon->VSSetConstantBuffers(UNIFORM_SLOT::OBJECT, 1, &objectUniformBuffer);
}
void ObjectUniform::SetObjectUniformBufferPS(ID3D11DeviceContext* d3d11DevCon)
{
d3d11DevCon->PSSetConstantBuffers(UNIFORM_SLOT::OBJECT, 1, &objectUniformBuffer);
}
void ObjectUniform::SetObjectUniformBufferVSPS(ID3D11DeviceContext* d3d11DevCon)
{
SetObjectUniformBufferVS(d3d11DevCon);
SetObjectUniformBufferPS(d3d11DevCon);
}
void ObjectUniform::SetM(Transform* pTransform)
{
XMMATRIX temp = pTransform->GetTransform();
XMStoreFloat4x4(&objectUniformData.M, temp);
}
void ObjectUniform::SetM_INV(Transform* pTransform)
{
XMMATRIX temp = pTransform->GetTransform();
XMStoreFloat4x4(&objectUniformData.M, temp);
XMStoreFloat4x4(&objectUniformData.M_INV, XMMatrixInverse(nullptr, temp));
}
void ObjectUniform::SetM_INV_TRANS(Transform* pTransform)
{
XMMATRIX temp = pTransform->GetTransform();
XMStoreFloat4x4(&objectUniformData.M, temp);
XMStoreFloat4x4(&objectUniformData.M_INV, XMMatrixInverse(nullptr, temp));
XMStoreFloat4x4(&objectUniformData.M_INV_TRANS, XMMatrixTranspose(XMMatrixInverse(nullptr, temp)));
}
void ObjectUniform::ApplyTransform(Transform* pTransform)
{
SetM_INV_TRANS(pTransform);
needToUpload = true;
}
bool ObjectUniform::InitObjectUniform(ID3D11Device* d3d11Device, ID3D11DeviceContext* d3d11DevCon)
{
if (!CreateBuffer(d3d11Device)) return false;
ObjectUniformBufferData(d3d11DevCon);
SetObjectUniformBufferVSPS(d3d11DevCon);
printf("objectUniform create buffer done!\n");
return true;
}
bool ObjectUniform::NeedToUpload()
{
return needToUpload;
} | [
"[email protected]"
] | |
189f257f4c71ab8852fdb1f25dc5569aa7718cc7 | de7e771699065ec21a340ada1060a3cf0bec3091 | /analysis/icu/src/test/org/apache/lucene/collation/TestICUCollationDocValuesField.cpp | 3e65623893e0b94c3ba662aa88b6822d1def66e6 | [] | no_license | sraihan73/Lucene- | 0d7290bacba05c33b8d5762e0a2a30c1ec8cf110 | 1fe2b48428dcbd1feb3e10202ec991a5ca0d54f3 | refs/heads/master | 2020-03-31T07:23:46.505891 | 2018-12-08T14:57:54 | 2018-12-08T14:57:54 | 152,020,180 | 7 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 6,388 | cpp | using namespace std;
#include "TestICUCollationDocValuesField.h"
#include "../../../../../../../../core/src/java/org/apache/lucene/document/Document.h"
#include "../../../../../../../../core/src/java/org/apache/lucene/document/Field.h"
#include "../../../../../../../../core/src/java/org/apache/lucene/document/StringField.h"
#include "../../../../../../../../core/src/java/org/apache/lucene/index/IndexReader.h"
#include "../../../../../../../../core/src/java/org/apache/lucene/index/MultiDocValues.h"
#include "../../../../../../../../core/src/java/org/apache/lucene/index/SortedDocValues.h"
#include "../../../../../../../../core/src/java/org/apache/lucene/search/IndexSearcher.h"
#include "../../../../../../../../core/src/java/org/apache/lucene/search/MatchAllDocsQuery.h"
#include "../../../../../../../../core/src/java/org/apache/lucene/search/Sort.h"
#include "../../../../../../../../core/src/java/org/apache/lucene/search/SortField.h"
#include "../../../../../../../../core/src/java/org/apache/lucene/search/TopDocs.h"
#include "../../../../../../../../core/src/java/org/apache/lucene/store/Directory.h"
#include "../../../../../../../../core/src/java/org/apache/lucene/util/BytesRef.h"
#include "../../../../../../../../test-framework/src/java/org/apache/lucene/index/RandomIndexWriter.h"
#include "../../../../../../../../test-framework/src/java/org/apache/lucene/util/TestUtil.h"
#include "../../../../../java/org/apache/lucene/collation/ICUCollationDocValuesField.h"
namespace org::apache::lucene::collation
{
using Document = org::apache::lucene::document::Document;
using Field = org::apache::lucene::document::Field;
using StringField = org::apache::lucene::document::StringField;
using IndexReader = org::apache::lucene::index::IndexReader;
using MultiDocValues = org::apache::lucene::index::MultiDocValues;
using RandomIndexWriter = org::apache::lucene::index::RandomIndexWriter;
using SortedDocValues = org::apache::lucene::index::SortedDocValues;
using IndexSearcher = org::apache::lucene::search::IndexSearcher;
using MatchAllDocsQuery = org::apache::lucene::search::MatchAllDocsQuery;
using Sort = org::apache::lucene::search::Sort;
using SortField = org::apache::lucene::search::SortField;
using TopDocs = org::apache::lucene::search::TopDocs;
using Directory = org::apache::lucene::store::Directory;
using BytesRef = org::apache::lucene::util::BytesRef;
using LuceneTestCase = org::apache::lucene::util::LuceneTestCase;
using TestUtil = org::apache::lucene::util::TestUtil;
using com::ibm::icu::text::Collator;
using com::ibm::icu::util::ULocale;
void TestICUCollationDocValuesField::testBasic()
{
shared_ptr<Directory> dir = newDirectory();
shared_ptr<RandomIndexWriter> iw =
make_shared<RandomIndexWriter>(random(), dir);
shared_ptr<Document> doc = make_shared<Document>();
shared_ptr<Field> field = newField(L"field", L"", StringField::TYPE_STORED);
shared_ptr<ICUCollationDocValuesField> collationField =
make_shared<ICUCollationDocValuesField>(
L"collated", Collator::getInstance(ULocale::ENGLISH));
doc->push_back(field);
doc->push_back(collationField);
field->setStringValue(L"ABC");
collationField->setStringValue(L"ABC");
iw->addDocument(doc);
field->setStringValue(L"abc");
collationField->setStringValue(L"abc");
iw->addDocument(doc);
shared_ptr<IndexReader> ir = iw->getReader();
delete iw;
shared_ptr<IndexSearcher> is = newSearcher(ir);
shared_ptr<SortField> sortField =
make_shared<SortField>(L"collated", SortField::Type::STRING);
shared_ptr<TopDocs> td = is->search(make_shared<MatchAllDocsQuery>(), 5,
make_shared<Sort>(sortField));
TestUtil::assertEquals(L"abc", ir->document(td->scoreDocs[0]->doc)[L"field"]);
TestUtil::assertEquals(L"ABC", ir->document(td->scoreDocs[1]->doc)[L"field"]);
delete ir;
delete dir;
}
void TestICUCollationDocValuesField::testRanges()
{
shared_ptr<Directory> dir = newDirectory();
shared_ptr<RandomIndexWriter> iw =
make_shared<RandomIndexWriter>(random(), dir);
shared_ptr<Document> doc = make_shared<Document>();
shared_ptr<Field> field = newField(L"field", L"", StringField::TYPE_STORED);
shared_ptr<Collator> collator =
Collator::getInstance(); // uses -Dtests.locale
if (random()->nextBoolean()) {
collator->setStrength(Collator::PRIMARY);
}
shared_ptr<ICUCollationDocValuesField> collationField =
make_shared<ICUCollationDocValuesField>(L"collated", collator);
doc->push_back(field);
doc->push_back(collationField);
int numDocs = atLeast(500);
for (int i = 0; i < numDocs; i++) {
wstring value = TestUtil::randomSimpleString(random());
field->setStringValue(value);
collationField->setStringValue(value);
iw->addDocument(doc);
}
shared_ptr<IndexReader> ir = iw->getReader();
delete iw;
shared_ptr<IndexSearcher> is = newSearcher(ir);
int numChecks = atLeast(100);
for (int i = 0; i < numChecks; i++) {
wstring start = TestUtil::randomSimpleString(random());
wstring end = TestUtil::randomSimpleString(random());
shared_ptr<BytesRef> lowerVal =
make_shared<BytesRef>(collator->getCollationKey(start).toByteArray());
shared_ptr<BytesRef> upperVal =
make_shared<BytesRef>(collator->getCollationKey(end).toByteArray());
doTestRanges(is, start, end, lowerVal, upperVal, collator);
}
delete ir;
delete dir;
}
void TestICUCollationDocValuesField::doTestRanges(
shared_ptr<IndexSearcher> is, const wstring &startPoint,
const wstring &endPoint, shared_ptr<BytesRef> startBR,
shared_ptr<BytesRef> endBR,
shared_ptr<Collator> collator)
{
shared_ptr<SortedDocValues> dvs =
MultiDocValues::getSortedValues(is->getIndexReader(), L"collated");
for (int docID = 0; docID < is->getIndexReader()->maxDoc(); docID++) {
shared_ptr<Document> doc = is->doc(docID);
wstring s = doc->getField(L"field")->stringValue();
bool collatorAccepts = collator->compare(s, startPoint) >= 0 &&
collator->compare(s, endPoint) <= 0;
TestUtil::assertEquals(docID, dvs->nextDoc());
shared_ptr<BytesRef> br = dvs->binaryValue();
bool luceneAccepts =
br->compareTo(startBR) >= 0 && br->compareTo(endBR) <= 0;
TestUtil::assertEquals(collatorAccepts, luceneAccepts);
}
}
} // namespace org::apache::lucene::collation | [
"[email protected]"
] | |
46c476101e7fbd72f3b0ce35a7f5520a2fd44571 | 5111cebf203f524c060821fce6555867b1af8846 | /Broadcaster.h | ae9163d89a8fd1a932c21ea7f64e491dd09e5f43 | [] | no_license | skalahonza/RizeniOsvetleni | bdad0d90199082b8504fba5246f5346eafedf678 | 5c8f2615449e5ac37e112534bfe208ca214ca8e9 | refs/heads/master | 2021-01-21T15:21:59.353533 | 2017-05-23T11:10:46 | 2017-05-23T11:10:46 | 95,384,217 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,358 | h | //
// Created by skala on 17.5.17.
//
#ifndef UDPTASK_BROADCASTER_H
#define UDPTASK_BROADCASTER_H
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <string.h>
#include <unistd.h>
#include <sys/select.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netdb.h>
#include "LightUnit.h"
#include "Message.h"
class Broadcaster {
private:
Broadcaster();
Broadcaster(Broadcaster const &); // Don't Implement
void operator=(Broadcaster const &); // Don't implement
void errno_abort(const char *header);
sockaddr_in braddr;
int sockfd;
public:
/**
* Get singleton instance or create a new one
* @return Broadcaster singleton instance
*/
static Broadcaster &getInstance() {
static Broadcaster INSTANCE;
return INSTANCE;
}
/**
* Broadcasts given buffer to all listeners in LAN
* @param data Raw bytes data
* @param len BUffer length
*/
void broadcastData(char *data, int len);
/**
* Broadcasts given unit information to all listeners in LAN
* @param unit LightUnit to be broadcaster
*/
void broadcastData(LightUnit unit);
/**
* Broadcast given message to all listeners in LAN
* @param message Message to be broadcasted
*/
void broadcastData(Message *message);
};
#endif //UDPTASK_BROADCASTER_H
| [
"[email protected]"
] | |
4f7818f18a70c0be8dadf2cb78d6f821c8bcf2d2 | 47334dfe26797df79b7fcd880fae31dc315f525f | /kattis/Math/Santa Klas.cpp | 556c40b50beaee4c1ab28e63cb301a1da2d738ba | [] | no_license | chinhhi102/GiaiThuat | 08d787701ca47c9053d56978e3f0d7c451328d6f | 4f9fd2810fe4565e35d676c28762836d94d4560d | refs/heads/master | 2020-09-22T07:59:13.193561 | 2019-12-27T17:09:00 | 2019-12-27T17:09:00 | 225,110,911 | 0 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 1,619 | cpp | #include <map>
#include <set>
#include <queue>
#include <cmath>
#include <vector>
#include <cstdio>
#include <bitset>
#include <cstring>
#include <cstdlib>
#include <complex>
#include <iostream>
#include <algorithm>
#include <math.h>
#include <iomanip>
#include <list>
#include <ctype.h>
#include <stack>
#include <iterator>
#include <complex>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <functional>
#include <time.h>
//#include <unordered_map>
using namespace std;
#define io ios_base::sync_with_stdio(0),cin.tie(0),cout.tie(0)
#define fora(i,a,b) for(int i=a;i<b;i++)
#define fors(i,a,b) for(int i=a-1;i>=b;i--)
#define men(a) menset(a,0,sizeof(a))
#define sc(x) scanf("%d",&x)
#define scll(x) scanf("%lld",&x)
#define c1(a) cin>>a
#define c2(a,b) cin>>a>>b
#define c3(a,b,c) cin>>a>>b>>c
#define pb push_back
#define ff first
#define ss second
#define all(x) (x).begin(), (x).end()
#define M_PI 3.14159265358979323846
#define fix(x) cout<<fixed<<setprecision(x)
typedef unsigned long long ull;
typedef long long ll;
typedef long double ld;
typedef pair<int,int> pi;
typedef pair<ll,ll> pll;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef vector<bool> vb;
typedef vector<vector<int> > vvi;
typedef map<int,int> mi;
typedef map<long,long> mll;
int main(){
io;
int h,v;
cin>>h>>v;
if(v>=0&&v<=180)
cout<<"safe";
else {
if(v>=270)
v-=270;
else{
v=270-v;
}
if(v==0)
cout<<h;
else{
double v_rad = v*M_PI / 180.0;
double sinv = sin(M_PI/2 - v_rad);
double time = h / sinv;
cout << int(time) << endl;
}
}
return 0;
}
| [
"[email protected]"
] | |
9bf53a360cab879c9b7e10c5bed80d4c1cf10de5 | c57819bebe1a3e1d305ae0cb869cdcc48c7181d1 | /src/qt/src/gui/kernel/qsound.h | 333d6e6eb37c2defda4467fed3ad6752509b76bf | [
"LGPL-2.1-only",
"Qt-LGPL-exception-1.1",
"LicenseRef-scancode-generic-exception",
"GPL-3.0-only",
"GPL-1.0-or-later",
"GFDL-1.3-only",
"BSD-3-Clause"
] | permissive | blowery/phantomjs | 255829570e90a28d1cd597192e20314578ef0276 | f929d2b04a29ff6c3c5b47cd08a8f741b1335c72 | refs/heads/master | 2023-04-08T01:22:35.426692 | 2012-10-11T17:43:24 | 2012-10-11T17:43:24 | 6,177,895 | 1 | 0 | BSD-3-Clause | 2023-04-03T23:09:40 | 2012-10-11T17:39:25 | C++ | UTF-8 | C++ | false | false | 2,645 | h | /****************************************************************************
**
** Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies).
** All rights reserved.
** Contact: Nokia Corporation ([email protected])
**
** This file is part of the QtGui module of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:LGPL$
** GNU Lesser General Public License Usage
** This file may be used under the terms of the GNU Lesser General Public
** License version 2.1 as published by the Free Software Foundation and
** appearing in the file LICENSE.LGPL included in the packaging of this
** file. Please review the following information to ensure the GNU Lesser
** General Public License version 2.1 requirements will be met:
** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
**
** In addition, as a special exception, Nokia gives you certain additional
** rights. These rights are described in the Nokia Qt LGPL Exception
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU General
** Public License version 3.0 as published by the Free Software Foundation
** and appearing in the file LICENSE.GPL included in the packaging of this
** file. Please review the following information to ensure the GNU General
** Public License version 3.0 requirements will be met:
** http://www.gnu.org/copyleft/gpl.html.
**
** Other Usage
** Alternatively, this file may be used in accordance with the terms and
** conditions contained in a signed written agreement between you and Nokia.
**
**
**
**
**
** $QT_END_LICENSE$
**
****************************************************************************/
#ifndef QSOUND_H
#define QSOUND_H
#include <QtCore/qobject.h>
QT_BEGIN_HEADER
QT_BEGIN_NAMESPACE
QT_MODULE(Gui)
#ifndef QT_NO_SOUND
class QSoundPrivate;
class Q_GUI_EXPORT QSound : public QObject
{
Q_OBJECT
public:
static bool isAvailable();
static void play(const QString& filename);
explicit QSound(const QString& filename, QObject* parent = 0);
~QSound();
int loops() const;
int loopsRemaining() const;
void setLoops(int);
QString fileName() const;
bool isFinished() const;
public Q_SLOTS:
void play();
void stop();
public:
#ifdef QT3_SUPPORT
QT3_SUPPORT_CONSTRUCTOR QSound(const QString& filename, QObject* parent, const char* name);
static inline QT3_SUPPORT bool available() { return isAvailable(); }
#endif
private:
Q_DECLARE_PRIVATE(QSound)
friend class QAuServer;
};
#endif // QT_NO_SOUND
QT_END_NAMESPACE
QT_END_HEADER
#endif // QSOUND_H
| [
"[email protected]"
] | |
b26061b03ef24050f29681f193dbfd9c9e3d0e9e | 3ae80dbc18ed3e89bedf846d098b2a98d8e4b776 | /src/Map/ShortestPathFinder.cpp | 5fedae04d299bd762b7dea18a90ad24eda344262 | [] | no_license | sswroom/SClass | deee467349ca249a7401f5d3c177cdf763a253ca | 9a403ec67c6c4dfd2402f19d44c6573e25d4b347 | refs/heads/main | 2023-09-01T07:24:58.907606 | 2023-08-31T11:24:34 | 2023-08-31T11:24:34 | 329,970,172 | 10 | 7 | null | null | null | null | UTF-8 | C++ | false | false | 11,458 | cpp | #include "Stdafx.h"
#include "Map/ShortestPathFinder.h"
#include "Math/Math.h"
#include "Text/MyString.h"
Int64 Map::ShortestPathFinder::CoordToId(Double x, Double y)
{
if (cu == CU_DEGREE)
{
return (Double2Int64(x * 1000000.0) << 32) | (UInt32)Double2Int32(y * 1000000.0);
}
else
{
return (Double2Int64(x * 10.0) << 32) | (UInt32)Double2Int32(y * 10.0);
}
}
Bool Map::ShortestPathFinder::SearchShortestPath(Data::ArrayList<Double> *pointList, void *sess, Int64 fromObjId, Double fromX, Double fromY, Int64 toObjId, Double toX, Double toY)
{
UOSInt i;
Math::Polyline *pl;
UOSInt fromPointNo;
UOSInt toPointNo;
Int64 toId1;
Int64 toId2;
UTF8Char sbuff1[256];
UTF8Char sbuff2[256];
sbuff1[0] = 0;
sbuff2[0] = 0;
this->layer->GetString(sbuff1, sizeof(sbuff1), this->nameArr, fromObjId, this->nameCol);
this->layer->GetString(sbuff2, sizeof(sbuff2), this->nameArr, toObjId, this->nameCol);
if (Text::StrEquals(sbuff1, sbuff2))
{
Double dist1;
Double dist2;
Double xDiff;
Double yDiff;
Double *points;
UOSInt nPoints;
Int64 nextId;
Int64 lastId;
OSInt pathCnt;
NodeInfo *node;
NeighbourInfo *neighbour;
Bool valid = true;
pl = (Math::Polyline*)this->layer->GetNewVectorById(sess, toObjId);
toPointNo = pl->GetPointNo(toX, toY, 0, 0, 0);
points = pl->GetPointList(&nPoints);
toId1 = this->CoordToId(points[0], points[1]);
Bool bothDir = true;
if (this->dirCol >= 0)
{
if (layer->GetString(sbuff2, sizeof(sbuff2), nameArr, toObjId, dirCol))
{
if (Text::StrToInt32(sbuff2) == 3)
{
bothDir = false;
}
}
}
if (bothDir)
{
toId2 = this->CoordToId(points[nPoints * 2 - 2], points[nPoints * 2 - 1]);
}
else
{
toId2 = toId1;
}
DEL_CLASS(pl);
pl = (Math::Polyline*)this->layer->GetNewVectorById(sess, fromObjId);
points = pl->GetPointList(&nPoints);
fromPointNo = pl->GetPointNo(fromX, fromY, 0, 0, 0);
bothDir = false;
if (this->dirCol >= 0)
{
if (layer->GetString(sbuff2, sizeof(sbuff2), nameArr, fromObjId, dirCol))
{
if (Text::StrToInt32(sbuff2) == 3)
{
bothDir = false;
}
}
}
if (bothDir)
{
xDiff = points[0] - toX;
yDiff = points[1] - toY;
dist1 = xDiff * xDiff - yDiff * yDiff;
xDiff = points[nPoints * 2 - 2] - toX;
yDiff = points[nPoints * 2 - 1] - toY;
dist2 = xDiff * xDiff - yDiff * yDiff;
if (dist1 < dist2)
{
pointList->Add(fromX);
pointList->Add(fromY);
i = fromPointNo;
while (i >= 0)
{
pointList->Add(points[i * 2]);
pointList->Add(points[i * 2 + 1]);
i--;
}
nextId = this->CoordToId(points[0], points[1]);
lastId = this->CoordToId(points[nPoints * 2 - 2], points[nPoints * 2 - 1]);
}
else
{
pointList->Add(fromX);
pointList->Add(fromY);
i = fromPointNo + 1;
while (i < nPoints)
{
pointList->Add(points[i * 2]);
pointList->Add(points[i * 2 + 1]);
i++;
}
nextId = this->CoordToId(points[nPoints * 2 - 2], points[nPoints * 2 - 1]);
lastId = this->CoordToId(points[0], points[1]);
}
}
else
{
nextId = this->CoordToId(points[nPoints * 2 - 2], points[nPoints * 2 - 1]);
lastId = this->CoordToId(points[0], points[1]);
}
DEL_CLASS(pl);
pathCnt = 0;
while (true)
{
if (nextId == toId1)
{
pl = (Math::Polyline*)this->layer->GetNewVectorById(sess, toObjId);
points = pl->GetPointList(&nPoints);
i = 1;
while (i <= toPointNo)
{
pointList->Add(points[i * 2]);
pointList->Add(points[i * 2 + 1]);
i++;
}
pointList->Add(toX);
pointList->Add(toY);
DEL_CLASS(pl);
break;
}
else if (nextId == toId2)
{
pl = (Math::Polyline*)this->layer->GetNewVectorById(sess, toObjId);
points = pl->GetPointList(&nPoints);
i = nPoints - 1;
while (i > toPointNo)
{
pointList->Add(points[i * 2]);
pointList->Add(points[i * 2 + 1]);
i--;
}
pointList->Add(toX);
pointList->Add(toY);
DEL_CLASS(pl);
break;
}
else
{
Bool found = false;
node = this->nodeMap->Get(nextId);
i = node->neighbours->GetCount();
while (i-- > 0)
{
neighbour = node->neighbours->GetItem(i);
if (this->CoordToId(neighbour->x, neighbour->y) != lastId && neighbour->name && Text::StrEquals(sbuff1, neighbour->name))
{
lastId = nextId;
nextId = this->CoordToId(neighbour->x, neighbour->y);
points = neighbour->pl->GetPointList(&nPoints);
if (neighbour->isReversed)
{
i = nPoints - 1;
while (i-- > 0)
{
pointList->Add(points[i * 2]);
pointList->Add(points[i * 2 + 1]);
}
}
else
{
i = 1;
while (i < nPoints)
{
pointList->Add(points[i * 2]);
pointList->Add(points[i * 2 + 1]);
i++;
}
}
pathCnt++;
found = true;
break;
}
}
if (!found)
{
valid = false;
break;
}
if (pathCnt > 20)
{
valid = false;
break;
}
}
}
if (valid)
{
return true;
}
else
{
pointList->Clear();
return false;
}
}
else
{
return false;
}
}
Map::ShortestPathFinder::ShortestPathFinder(Map::MapDrawLayer *layer, Bool toRelease, CoordinateUnit cu, OSInt nameCol, OSInt dirCol)
{
this->layer = layer;
this->toRelease = toRelease;
this->cu = cu;
this->nameCol = nameCol;
this->dirCol = dirCol;
NEW_CLASS(this->nodeMap, Data::Int64Map<NodeInfo*>());
UTF8Char sbuff[256];
Data::ArrayListInt64 idList;
Math::Geometry::Vector2D *vec;
Math::Polyline *pl;
NodeInfo *fromNode;
NodeInfo *toNode;
Int64 fromId;
Int64 toId;
NeighbourInfo *frNeighbour;
NeighbourInfo *toNeighbour;
Double dist;
UOSInt nPoints;
Double *points;
Double xDiff;
Double yDiff;
void *sess;
UOSInt i;
UOSInt j;
UOSInt k;
layer->GetAllObjectIds(&idList, &this->nameArr);
sess = layer->BeginGetObject();
i = 0;
j = idList.GetCount();
while (i < j)
{
vec = layer->GetNewVectorById(sess, idList.GetItem(i));
if (vec)
{
if (vec->GetVectorType() == Math::Geometry::Vector2D::VectorType::Polyline)
{
pl = (Math::Polyline *)vec;
points = pl->GetPointList(&nPoints);
dist = 0;
k = 1;
while (k < nPoints)
{
xDiff = points[k * 2 - 2] - points[k * 2];
yDiff = points[k * 2 - 1] - points[k * 2 + 1];
dist += Math_Sqrt(xDiff * xDiff + yDiff * yDiff);
k++;
}
fromId = this->CoordToId(points[0], points[1]);
toId = this->CoordToId(points[nPoints * 2 - 2], points[nPoints * 2 - 1]);
fromNode = this->nodeMap->Get(fromId);
toNode = this->nodeMap->Get(toId);
if (fromNode == 0)
{
fromNode = MemAlloc(NodeInfo, 1);
fromNode->x = points[0];
fromNode->y = points[1];
NEW_CLASS(fromNode->neighbours, Data::ArrayList<NeighbourInfo*>());
this->nodeMap->Put(fromId, fromNode);
}
if (toNode == 0)
{
toNode = MemAlloc(NodeInfo, 1);
toNode->x = points[nPoints * 2 - 2];
toNode->y = points[nPoints * 2 - 1];
NEW_CLASS(toNode->neighbours, Data::ArrayList<NeighbourInfo*>());
this->nodeMap->Put(toId, toNode);
}
frNeighbour = MemAlloc(NeighbourInfo, 1);
frNeighbour->x = points[nPoints * 2 - 2];
frNeighbour->y = points[nPoints * 2 - 1];
frNeighbour->isReversed = false;
frNeighbour->pl = pl;
frNeighbour->dist = dist;
frNeighbour->name = 0;
Bool bothDir = true;
if (this->dirCol >= 0)
{
if (layer->GetString(sbuff, sizeof(sbuff), nameArr, idList.GetItem(i), dirCol))
{
if (Text::StrToInt32(sbuff) == 3)
{
bothDir = false;
}
}
}
if (bothDir)
{
toNeighbour = MemAlloc(NeighbourInfo, 1);
toNeighbour->x = points[0];
toNeighbour->y = points[1];
toNeighbour->isReversed = true;
toNeighbour->pl = pl;
toNeighbour->dist = dist;
toNeighbour->name = 0;
}
if (layer->GetString(sbuff, sizeof(sbuff), nameArr, idList.GetItem(i), nameCol))
{
frNeighbour->name = Text::StrCopyNew(sbuff);
if (bothDir)
{
toNeighbour->name = Text::StrCopyNew(sbuff);
}
}
fromNode->neighbours->Add(frNeighbour);
if (bothDir)
{
toNode->neighbours->Add(toNeighbour);
}
}
else
{
DEL_CLASS(vec);
}
}
i++;
}
layer->EndGetObject(sess);
}
Map::ShortestPathFinder::~ShortestPathFinder()
{
this->layer->ReleaseNameArr(this->nameArr);
if (this->toRelease)
{
DEL_CLASS(this->layer);
}
OSInt i;
OSInt j;
NodeInfo *node;
NeighbourInfo *neighbour;
Data::ArrayList<NodeInfo*> *nodeList = this->nodeMap->GetValues();
i = nodeList->GetCount();
while (i-- > 0)
{
node = nodeList->GetItem(i);
j = node->neighbours->GetCount();
while (j-- > 0)
{
neighbour = node->neighbours->GetItem(j);
if (!neighbour->isReversed)
{
DEL_CLASS(neighbour->pl);
}
SDEL_TEXT(neighbour->name);
MemFree(neighbour);
}
}
DEL_CLASS(this->nodeMap);
}
Math::Polyline *Map::ShortestPathFinder::GetPath(Double fromX, Double fromY, Double toX, Double toY, Bool sameName)
{
Math::Polyline *retPl = 0;
Data::ArrayList<Double> pointList;
OSInt i;
OSInt j;
OSInt fromCnt;
OSInt toCnt;
UOSInt nPoints;
Data::ArrayList<Map::MapDrawLayer::ObjectInfo *> fromObjs;
Data::ArrayList<Map::MapDrawLayer::ObjectInfo *> toObjs;
Map::MapDrawLayer::ObjectInfo *fromObj;
Map::MapDrawLayer::ObjectInfo *toObj;
void *sess;
sess = this->layer->BeginGetObject();
if (this->cu == Map::ShortestPathFinder::CU_METER)
{
this->layer->GetNearObjects(sess, &fromObjs, fromX, fromY, 30);
this->layer->GetNearObjects(sess, &toObjs, toX, toY, 30);
}
else
{
this->layer->GetNearObjects(sess, &fromObjs, fromX, fromY, 0.00015);
this->layer->GetNearObjects(sess, &toObjs, toX, toY, 0.00015);
}
fromCnt = fromObjs.GetCount();
toCnt = toObjs.GetCount();
i = 0;
while (i < fromCnt)
{
fromObj = fromObjs.GetItem(i);
j = 0;
while (j < toCnt && j <= i)
{
toObj = toObjs.GetItem(j);
pointList.Clear();
if (this->SearchShortestPath(&pointList, sess, fromObj->objId, fromObj->objX, fromObj->objY, toObj->objId, toObj->objX, toObj->objY))
{
NEW_CLASS(retPl, Math::Polyline(0, pointList.GetArray(&nPoints), pointList.GetCount() >> 1));
break;
}
j++;
}
if (retPl)
break;
i++;
}
if (retPl == 0)
{
j = fromCnt + 1;
while (j < toCnt)
{
toObj = toObjs.GetItem(j);
i = 0;
while (i < fromCnt)
{
fromObj = fromObjs.GetItem(i);
pointList.Clear();
if (this->SearchShortestPath(&pointList, sess, fromObj->objId, fromObj->objX, fromObj->objY, toObj->objId, toObj->objX, toObj->objY))
{
NEW_CLASS(retPl, Math::Polyline(0, pointList.GetArray(&nPoints), pointList.GetCount() >> 1));
break;
}
i++;
}
if (retPl)
break;
j++;
}
}
this->layer->FreeObjects(&fromObjs);
this->layer->FreeObjects(&toObjs);
this->layer->EndGetObject(sess);
if (retPl == 0)
{
return 0;
}
return retPl;
}
| [
"[email protected]"
] | |
5ca12b2cee727b8fc34c0d924ab6855f550efcf7 | 6603591068b6e838e60c202a806bd6864e98d59c | /examples/StarterPro/BroadTest/BroadTest.ino | 4849db447a8f4fb2e135456aab16e440fd80fddf | [] | no_license | ZeroWorkshop/Zeroworksop-Libraries-master | 6dc0dce5e63c255389449fe9aadc00124138dc3e | 18b6a8540af499f29d198ba1a969359c52d2cf90 | refs/heads/master | 2020-06-04T08:55:42.925968 | 2019-06-14T14:09:06 | 2019-06-14T14:09:06 | 191,952,967 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,086 | ino | #include <Wire.h>
#include "StarterPro.h"
#include <ZeroMotors.h>
#include <Pushbutton.h>
#define _INCLUDE_BUZZER_
ZeroMotors motors;
Pushbutton START(ZERO_BUTTON);
void setup()
{
playPowerOn();
pinMode(ZW_A1,INPUT);
pinMode(ZW_A2,INPUT);
pinMode(ZW_A3,INPUT);
pinMode(ZW_A4,INPUT);
pinMode(ZW_B1,OUTPUT);
pinMode(ZW_B2,OUTPUT);
pinMode(ZW_B3,OUTPUT);
pinMode(ZW_B4,OUTPUT);
digitalWrite(ZW_B1,LOW);
digitalWrite(ZW_B2,LOW);
digitalWrite(ZW_B3,LOW);
digitalWrite(ZW_B4,LOW);
motors.motorControl(M1,0);
motors.motorControl(M2,0);
motors.motorControl(M3,0);
motors.motorControl(M4,0);
Serial.begin(115200);
START.waitForButton();
playStart();
}
void loop()
{
// run left motor forward
int a1_val,a2_val,a3_val,a4_val;
a1_val = digitalRead(ZW_A1);
a2_val = digitalRead(ZW_A2);
a3_val = digitalRead(ZW_A3);
a4_val = digitalRead(ZW_A4);
Serial.print(a1_val);Serial.print("\t");
Serial.print(a2_val);Serial.print("\t");
Serial.print(a3_val);Serial.print("\t");
Serial.print(a4_val);Serial.println("\t");
if(a1_val == 0 && a2_val == 1 && a3_val == 1 && a4_val ==1)
{
digitalWrite(ZW_B1,HIGH);
motors.motorControl(M1,255);
motors.motorControl(M2,255);
}
else if(a1_val == 1 && a2_val == 0 && a3_val == 1 && a4_val == 1)
{
digitalWrite(ZW_B2,HIGH);
motors.motorControl(M1,-255);
motors.motorControl(M2,-255);
}
else if(a1_val == 1 && a2_val == 1 && a3_val == 0 && a4_val == 1)
{
digitalWrite(ZW_B3,HIGH);
motors.motorControl(M3,255);
motors.motorControl(M4,255);
}
else if(a1_val == 1 && a2_val == 1 && a3_val == 1 && a4_val == 0)
{
digitalWrite(ZW_B4,HIGH);
motors.motorControl(M3,-255);
motors.motorControl(M4,-255);
}
else
{
digitalWrite(ZW_B1,LOW);
digitalWrite(ZW_B2,LOW);
digitalWrite(ZW_B3,LOW);
digitalWrite(ZW_B4,LOW);
motors.motorControl(M1,0);
motors.motorControl(M2,0);
motors.motorControl(M3,0);
motors.motorControl(M4,0);
}
} | [
"[email protected]"
] | |
ce4bc3212937ff607e5c500c6f9746dac8af5ebe | b8dec2c84b114f7893b691cbb68f35182cb79a84 | /Polyhedron/cpp/common.hpp | 92ff37ca00697ec6415fffdb12eb31583aeecc92 | [] | no_license | rforcen/polyhedronisme-python | 58e608f75d9ef1b6f4cc2a57c56a590d99a0c003 | a66155f37b1c9c40f28f4633fae62db149b14dd5 | refs/heads/master | 2020-07-12T01:57:30.584119 | 2019-09-12T08:17:53 | 2019-09-12T08:17:53 | 204,689,436 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 547 | hpp | //
// common.hpp
// test_polygon
//
// Created by asd on 03/09/2019.
// Copyright © 2019 voicesync. All rights reserved.
//
#ifndef common_h
#define common_h
#include <stdlib.h>
#include <vector>
#include <string>
#include <map>
#include <algorithm>
#include <simd/simd.h>
using std::vector, std::string, std::map, std::to_string, std::pair, std::reverse;
typedef simd_float3 Vertex;
typedef vector<Vertex> Vertexes;
typedef vector<int>Face;
typedef vector<Face>Faces;
typedef vector<vector<float>> VertexesFloat;
#endif /* common_h */
| [
"[email protected]"
] | |
3177f87cdff2160188e9a8a93d6d047fd9a685ea | e637cebd1ee538624cdbde83146d380f9d266687 | /C++/windSimAutomation/windSimAutomation/readConfigFile.h | 702fdd3c533efb67436a3d12fbdf88909a3471b6 | [] | no_license | latwood/fireLabWork | 3809b1c0cfc60a61b764fea6e17d2af8a2354de9 | fe99852e8279fa53bfc512682c433ddcf343b2bc | refs/heads/master | 2021-01-19T16:20:53.764982 | 2018-07-26T05:57:52 | 2018-07-26T05:57:52 | 101,000,951 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 135 | h | #ifndef READCONFIGFILE_H
#define READCONFIGFILE_H
class readConfigFile
{
public:
readConfigFile();
};
#endif // READCONFIGFILE_H
| [
"[email protected]"
] | |
c8b4dde45d30e230cc7107f5a88b8857635f72cf | 5d6880f0c61f5944290a24043661445c194e5ad4 | /icmp/ICMPSniffer/icmp/exceptions.cpp | 3273f6b43e40016afd96d4ecc2d37568a8ca7faf | [] | no_license | vairad/zcu-psi | a43df0076d5909794cbad8582824c9b72067052d | d592a2382cae58ffd6ce951563cec0105ec966bb | refs/heads/master | 2021-01-24T00:02:38.930742 | 2018-06-11T13:04:39 | 2018-06-11T13:04:39 | 122,744,689 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 236 | cpp | #include "icmp/exceptions.h"
DNSException::DNSException(const char *msg){
this->msg = "";
this->msg += msg ;
}
DNSException::~DNSException() throw(){
}
const char* DNSException::what() const throw()
{
return msg.c_str();
}
| [
"[email protected]"
] | |
1e4ca677969c3bb71bebdd9a44a6ff3d81f6ca76 | daa312bf4c1142933eb182db3ffe8177f44ce0f2 | /fact.cpp | 23178d76e1428595ab55d4b0800458fb9104785f | [] | no_license | StalinEPN97/EjemplosC_Cpp | 6a9f66fb196323e6d60e438acbdbe2a4094c0f02 | 95a831d2d520009d73428a5df1ed85edf5e6ec92 | refs/heads/master | 2020-05-23T06:08:52.461030 | 2019-06-26T15:23:04 | 2019-06-26T15:23:04 | 186,661,448 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 701 | cpp | #include<iostream>
using namespace std;
int FactorialIterativa(int n);
int FactorialRecursivo(int n);
int main()
{
int n, fact;
cout<< "Programar que calcule el factorial de un numero entre 2 y 10.\n" <<endl;
do
{
cout<< "Ingrese un valor" <<endl;
cin>>n;
}
while (n<2 || n>10);
fact = FactorialIterativa(n);
cout << "De forma iterativa de "<<n <<"! es ="<< fact ;
cout<<endl;
fact = FactorialRecursivo(n);
cout << "De forma recursivo de "<<n <<"! es ="<< fact ;
return 0;
}
//Factorila Iterativo
int FactorialIterativa (int n)
{
int fact, m;
for(m=n,fact=1; n>1; n--)
{
fact = fact * n;
}
return fact, c;
}
int FactorialRecursivo
{
return ( n<=1)? 1: n * Factorial()
}
| [
"[email protected]"
] | |
dfafa24c96e955e70cae9f93c8c8a091a7a339fa | a66611e52038bb67ceb005111b7d91a5aee36220 | /opencv-3.4.14/build_wasm/modules/core/opencl_kernels_core.cpp | acbc0ea3395743a4d0bd9bb8f7aea61394de86f5 | [] | no_license | mur6/opencv-wasm-build | 727703221090d4460c7c2db8e21f6ec4f6a88ebc | 8acf9a79b75d0a302dc940a99ae11e310a1a7c87 | refs/heads/master | 2023-06-11T15:43:43.456336 | 2021-06-24T10:26:40 | 2021-06-24T10:26:40 | 379,490,279 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 164,185 | cpp | // This file is auto-generated. Do not edit!
#include "opencv2/core.hpp"
#include "cvconfig.h"
#include "opencl_kernels_core.hpp"
#ifdef HAVE_OPENCL
namespace cv
{
namespace ocl
{
namespace core
{
static const char* const moduleName = "core";
struct cv::ocl::internal::ProgramEntry arithm_oclsrc={moduleName, "arithm",
"#ifdef DOUBLE_SUPPORT\n"
"#ifdef cl_amd_fp64\n"
"#pragma OPENCL EXTENSION cl_amd_fp64:enable\n"
"#elif defined cl_khr_fp64\n"
"#pragma OPENCL EXTENSION cl_khr_fp64:enable\n"
"#endif\n"
"#endif\n"
"#ifdef INTEL_DEVICE\n"
"#pragma OPENCL FP_CONTRACT ON\n"
"#pragma OPENCL FP_FAST_FMAF ON\n"
"#pragma OPENCL FP_FAST_FMA ON\n"
"#endif\n"
"#if !defined(DEPTH_dst)\n"
"#error \"Kernel configuration error: DEPTH_dst value is required\"\n"
"#elif !(DEPTH_dst >= 0 && DEPTH_dst <= 7)\n"
"#error \"Kernel configuration error: invalid DEPTH_dst value\"\n"
"#endif\n"
"#if defined(depth)\n"
"#error \"Kernel configuration error: ambiguous 'depth' value is defined, use 'DEPTH_dst' instead\"\n"
"#endif\n"
"#if DEPTH_dst < 5 \n"
"#define CV_DST_TYPE_IS_INTEGER\n"
"#else\n"
"#define CV_DST_TYPE_IS_FP\n"
"#endif\n"
"#if DEPTH_dst != 6 \n"
"#define CV_DST_TYPE_FIT_32F 1\n"
"#else\n"
"#define CV_DST_TYPE_FIT_32F 0\n"
"#endif\n"
"#if CV_DST_TYPE_FIT_32F\n"
"#define CV_PI M_PI_F\n"
"#else\n"
"#define CV_PI M_PI\n"
"#endif\n"
"#ifndef cn\n"
"#define cn 1\n"
"#endif\n"
"#if cn == 1\n"
"#undef srcT1_C1\n"
"#undef srcT2_C1\n"
"#undef dstT_C1\n"
"#define srcT1_C1 srcT1\n"
"#define srcT2_C1 srcT2\n"
"#define dstT_C1 dstT\n"
"#endif\n"
"#if cn != 3\n"
"#define storedst(val) *(__global dstT *)(dstptr + dst_index) = val\n"
"#define storedst2(val) *(__global dstT *)(dstptr2 + dst_index2) = val\n"
"#else\n"
"#define storedst(val) vstore3(val, 0, (__global dstT_C1 *)(dstptr + dst_index))\n"
"#define storedst2(val) vstore3(val, 0, (__global dstT_C1 *)(dstptr2 + dst_index2))\n"
"#endif\n"
"#define noconvert\n"
"#ifndef workT\n"
"#ifndef srcT1\n"
"#define srcT1 dstT\n"
"#endif\n"
"#ifndef srcT1_C1\n"
"#define srcT1_C1 dstT_C1\n"
"#endif\n"
"#ifndef srcT2\n"
"#define srcT2 dstT\n"
"#endif\n"
"#ifndef srcT2_C1\n"
"#define srcT2_C1 dstT_C1\n"
"#endif\n"
"#define workT dstT\n"
"#if cn != 3\n"
"#define srcelem1 *(__global srcT1 *)(srcptr1 + src1_index)\n"
"#define srcelem2 *(__global srcT2 *)(srcptr2 + src2_index)\n"
"#else\n"
"#define srcelem1 vload3(0, (__global srcT1_C1 *)(srcptr1 + src1_index))\n"
"#define srcelem2 vload3(0, (__global srcT2_C1 *)(srcptr2 + src2_index))\n"
"#endif\n"
"#ifndef convertToDT\n"
"#define convertToDT noconvert\n"
"#endif\n"
"#else\n"
"#ifndef convertToWT2\n"
"#define convertToWT2 convertToWT1\n"
"#endif\n"
"#if cn != 3\n"
"#define srcelem1 convertToWT1(*(__global srcT1 *)(srcptr1 + src1_index))\n"
"#define srcelem2 convertToWT2(*(__global srcT2 *)(srcptr2 + src2_index))\n"
"#else\n"
"#define srcelem1 convertToWT1(vload3(0, (__global srcT1_C1 *)(srcptr1 + src1_index)))\n"
"#define srcelem2 convertToWT2(vload3(0, (__global srcT2_C1 *)(srcptr2 + src2_index)))\n"
"#endif\n"
"#endif\n"
"#ifndef workST\n"
"#define workST workT\n"
"#endif\n"
"#define EXTRA_PARAMS\n"
"#define EXTRA_INDEX\n"
"#define EXTRA_INDEX_ADD\n"
"#if defined OP_ADD\n"
"#define PROCESS_ELEM storedst(convertToDT(srcelem1 + srcelem2))\n"
"#elif defined OP_SUB\n"
"#define PROCESS_ELEM storedst(convertToDT(srcelem1 - srcelem2))\n"
"#elif defined OP_RSUB\n"
"#define PROCESS_ELEM storedst(convertToDT(srcelem2 - srcelem1))\n"
"#elif defined OP_ABSDIFF\n"
"#if wdepth <= 4\n"
"#define PROCESS_ELEM \\\n"
"storedst(convertToDT(convertFromU(abs_diff(srcelem1, srcelem2))))\n"
"#else\n"
"#define PROCESS_ELEM \\\n"
"storedst(convertToDT(fabs(srcelem1 - srcelem2)))\n"
"#endif\n"
"#elif defined OP_AND\n"
"#define PROCESS_ELEM storedst(srcelem1 & srcelem2)\n"
"#elif defined OP_OR\n"
"#define PROCESS_ELEM storedst(srcelem1 | srcelem2)\n"
"#elif defined OP_XOR\n"
"#define PROCESS_ELEM storedst(srcelem1 ^ srcelem2)\n"
"#elif defined OP_NOT\n"
"#define PROCESS_ELEM storedst(~srcelem1)\n"
"#elif defined OP_MIN\n"
"#define PROCESS_ELEM storedst(min(srcelem1, srcelem2))\n"
"#elif defined OP_MAX\n"
"#define PROCESS_ELEM storedst(max(srcelem1, srcelem2))\n"
"#elif defined OP_MUL\n"
"#define PROCESS_ELEM storedst(convertToDT(srcelem1 * srcelem2))\n"
"#elif defined OP_MUL_SCALE\n"
"#undef EXTRA_PARAMS\n"
"#ifdef UNARY_OP\n"
"#define EXTRA_PARAMS , workST srcelem2_, scaleT scale\n"
"#undef srcelem2\n"
"#define srcelem2 srcelem2_\n"
"#else\n"
"#define EXTRA_PARAMS , scaleT scale\n"
"#endif\n"
"#define PROCESS_ELEM storedst(convertToDT(srcelem1 * scale * srcelem2))\n"
"#elif defined OP_DIV\n"
"#define PROCESS_ELEM \\\n"
"workT e2 = srcelem2, zero = (workT)(0); \\\n"
"storedst(convertToDT(e2 != zero ? srcelem1 / e2 : zero))\n"
"#elif defined OP_DIV_SCALE\n"
"#undef EXTRA_PARAMS\n"
"#ifdef UNARY_OP\n"
"#define EXTRA_PARAMS , workST srcelem2_, scaleT scale\n"
"#undef srcelem2\n"
"#define srcelem2 srcelem2_\n"
"#else\n"
"#define EXTRA_PARAMS , scaleT scale\n"
"#endif\n"
"#define PROCESS_ELEM \\\n"
"workT e2 = srcelem2, zero = (workT)(0); \\\n"
"storedst(convertToDT(e2 == zero ? zero : (srcelem1 * (workT)(scale) / e2)))\n"
"#elif defined OP_RDIV_SCALE\n"
"#undef EXTRA_PARAMS\n"
"#ifdef UNARY_OP\n"
"#define EXTRA_PARAMS , workST srcelem2_, scaleT scale\n"
"#undef srcelem2\n"
"#define srcelem2 srcelem2_\n"
"#else\n"
"#define EXTRA_PARAMS , scaleT scale\n"
"#endif\n"
"#define PROCESS_ELEM \\\n"
"workT e1 = srcelem1, zero = (workT)(0); \\\n"
"storedst(convertToDT(e1 == zero ? zero : (srcelem2 * (workT)(scale) / e1)))\n"
"#elif defined OP_RECIP_SCALE\n"
"#undef EXTRA_PARAMS\n"
"#define EXTRA_PARAMS , scaleT scale\n"
"#define PROCESS_ELEM \\\n"
"workT e1 = srcelem1, zero = (workT)(0); \\\n"
"storedst(convertToDT(e1 != zero ? scale / e1 : zero))\n"
"#elif defined OP_ADDW\n"
"#undef EXTRA_PARAMS\n"
"#define EXTRA_PARAMS , scaleT alpha, scaleT beta, scaleT gamma\n"
"#if wdepth <= 4\n"
"#define PROCESS_ELEM storedst(convertToDT(mad24(srcelem1, alpha, mad24(srcelem2, beta, gamma))))\n"
"#else\n"
"#define PROCESS_ELEM storedst(convertToDT(fma(srcelem1, alpha, fma(srcelem2, beta, gamma))))\n"
"#endif\n"
"#elif defined OP_MAG\n"
"#define PROCESS_ELEM storedst(hypot(srcelem1, srcelem2))\n"
"#elif defined OP_PHASE_RADIANS\n"
"#define PROCESS_ELEM \\\n"
"workT tmp = atan2(srcelem2, srcelem1); \\\n"
"if (tmp < 0) \\\n"
"tmp += 2 * CV_PI; \\\n"
"storedst(tmp)\n"
"#elif defined OP_PHASE_DEGREES\n"
"#define PROCESS_ELEM \\\n"
"workT tmp = degrees(atan2(srcelem2, srcelem1)); \\\n"
"if (tmp < 0) \\\n"
"tmp += 360; \\\n"
"storedst(tmp)\n"
"#elif defined OP_EXP\n"
"#if wdepth == 5\n"
"#define PROCESS_ELEM storedst(native_exp(srcelem1))\n"
"#else\n"
"#define PROCESS_ELEM storedst(exp(srcelem1))\n"
"#endif\n"
"#elif defined OP_POW\n"
"#define PROCESS_ELEM storedst(pow(srcelem1, srcelem2))\n"
"#elif defined OP_POWN\n"
"#undef workT\n"
"#define workT int\n"
"#define PROCESS_ELEM storedst(pown(srcelem1, srcelem2))\n"
"#elif defined OP_SQRT\n"
"#if CV_DST_TYPE_FIT_32F\n"
"#define PROCESS_ELEM storedst(native_sqrt(srcelem1))\n"
"#else\n"
"#define PROCESS_ELEM storedst(sqrt(srcelem1))\n"
"#endif\n"
"#elif defined OP_LOG\n"
"#define PROCESS_ELEM \\\n"
"storedst(log(fabs(srcelem1)))\n"
"#elif defined OP_CMP\n"
"#define srcT2 srcT1\n"
"#ifndef convertToWT1\n"
"#define convertToWT1\n"
"#endif\n"
"#define PROCESS_ELEM \\\n"
"storedst(srcelem1 CMP_OPERATOR srcelem2 ? (dstT)(255) : (dstT)(0))\n"
"#elif defined OP_CONVERT_SCALE_ABS\n"
"#undef EXTRA_PARAMS\n"
"#define EXTRA_PARAMS , workT1 alpha, workT1 beta\n"
"#if wdepth <= 4\n"
"#define PROCESS_ELEM \\\n"
"workT value = mad24(srcelem1, (workT)(alpha), (workT)(beta)); \\\n"
"storedst(convertToDT(abs(value)))\n"
"#else\n"
"#define PROCESS_ELEM \\\n"
"workT value = fma(srcelem1, (workT)(alpha), (workT)(beta)); \\\n"
"storedst(convertToDT(fabs(value)))\n"
"#endif\n"
"#elif defined OP_SCALE_ADD\n"
"#undef EXTRA_PARAMS\n"
"#define EXTRA_PARAMS , workT1 alpha\n"
"#if wdepth <= 4\n"
"#define PROCESS_ELEM storedst(convertToDT(mad24(srcelem1, (workT)(alpha), srcelem2)))\n"
"#else\n"
"#define PROCESS_ELEM storedst(convertToDT(fma(srcelem1, (workT)(alpha), srcelem2)))\n"
"#endif\n"
"#elif defined OP_CTP_AD || defined OP_CTP_AR\n"
"#if CV_DST_TYPE_FIT_32F\n"
"#define CV_EPSILON FLT_EPSILON\n"
"#else\n"
"#define CV_EPSILON DBL_EPSILON\n"
"#endif\n"
"#ifdef OP_CTP_AD\n"
"#define TO_DEGREE cartToPolar = degrees(cartToPolar);\n"
"#elif defined OP_CTP_AR\n"
"#define TO_DEGREE\n"
"#endif\n"
"#define PROCESS_ELEM \\\n"
"dstT x = srcelem1, y = srcelem2; \\\n"
"dstT x2 = x * x, y2 = y * y; \\\n"
"dstT magnitude = sqrt(x2 + y2); \\\n"
"dstT tmp = y >= 0 ? 0 : CV_PI * 2; \\\n"
"tmp = x < 0 ? CV_PI : tmp; \\\n"
"dstT tmp1 = y >= 0 ? CV_PI * 0.5f : CV_PI * 1.5f; \\\n"
"dstT cartToPolar = y2 <= x2 ? x * y / mad((dstT)(0.28f), y2, x2 + CV_EPSILON) + tmp : (tmp1 - x * y / mad((dstT)(0.28f), x2, y2 + CV_EPSILON)); \\\n"
"TO_DEGREE \\\n"
"storedst(magnitude); \\\n"
"storedst2(cartToPolar)\n"
"#elif defined OP_PTC_AD || defined OP_PTC_AR\n"
"#ifdef OP_PTC_AD\n"
"#define FROM_DEGREE y = radians(y)\n"
"#else\n"
"#define FROM_DEGREE\n"
"#endif\n"
"#define PROCESS_ELEM \\\n"
"dstT x = srcelem1, y = srcelem2, cosval; \\\n"
"FROM_DEGREE; \\\n"
"storedst2(sincos(y, &cosval) * x); \\\n"
"storedst(cosval * x);\n"
"#elif defined OP_PATCH_NANS\n"
"#undef EXTRA_PARAMS\n"
"#define EXTRA_PARAMS , dstT val\n"
"#define PROCESS_ELEM \\\n"
"if (isnan(srcelem1)) \\\n"
"storedst(val)\n"
"#else\n"
"#error \"unknown op type\"\n"
"#endif\n"
"#if defined OP_CTP_AD || defined OP_CTP_AR || defined OP_PTC_AD || defined OP_PTC_AR\n"
"#undef EXTRA_PARAMS\n"
"#define EXTRA_PARAMS , __global uchar* dstptr2, int dststep2, int dstoffset2\n"
"#undef EXTRA_INDEX\n"
"#define EXTRA_INDEX int dst_index2 = mad24(y0, dststep2, mad24(x, (int)sizeof(dstT_C1) * cn, dstoffset2))\n"
"#undef EXTRA_INDEX_ADD\n"
"#define EXTRA_INDEX_ADD dst_index2 += dststep2\n"
"#endif\n"
"#if defined UNARY_OP || defined MASK_UNARY_OP\n"
"#if defined OP_AND || defined OP_OR || defined OP_XOR || defined OP_ADD || defined OP_SAT_ADD || \\\n"
"defined OP_SUB || defined OP_SAT_SUB || defined OP_RSUB || defined OP_SAT_RSUB || \\\n"
"defined OP_ABSDIFF || defined OP_CMP || defined OP_MIN || defined OP_MAX || defined OP_POW || \\\n"
"defined OP_MUL || defined OP_DIV || defined OP_POWN || defined OP_POWR || defined OP_ROOTN\n"
"#undef EXTRA_PARAMS\n"
"#define EXTRA_PARAMS , workST srcelem2_\n"
"#undef srcelem2\n"
"#define srcelem2 srcelem2_\n"
"#endif\n"
"#if cn == 3\n"
"#undef srcelem2\n"
"#define srcelem2 (workT)(srcelem2_.x, srcelem2_.y, srcelem2_.z)\n"
"#endif\n"
"#endif\n"
"#if defined BINARY_OP\n"
"__kernel void KF(__global const uchar * srcptr1, int srcstep1, int srcoffset1,\n"
"__global const uchar * srcptr2, int srcstep2, int srcoffset2,\n"
"__global uchar * dstptr, int dststep, int dstoffset,\n"
"int rows, int cols EXTRA_PARAMS )\n"
"{\n"
"int x = get_global_id(0);\n"
"int y0 = get_global_id(1) * rowsPerWI;\n"
"if (x < cols)\n"
"{\n"
"int src1_index = mad24(y0, srcstep1, mad24(x, (int)sizeof(srcT1_C1) * cn, srcoffset1));\n"
"#if !(defined(OP_RECIP_SCALE) || defined(OP_NOT))\n"
"int src2_index = mad24(y0, srcstep2, mad24(x, (int)sizeof(srcT2_C1) * cn, srcoffset2));\n"
"#endif\n"
"int dst_index = mad24(y0, dststep, mad24(x, (int)sizeof(dstT_C1) * cn, dstoffset));\n"
"EXTRA_INDEX;\n"
"for (int y = y0, y1 = min(rows, y0 + rowsPerWI); y < y1; ++y, src1_index += srcstep1, dst_index += dststep)\n"
"{\n"
"PROCESS_ELEM;\n"
"#if !(defined(OP_RECIP_SCALE) || defined(OP_NOT))\n"
"src2_index += srcstep2;\n"
"#endif\n"
"EXTRA_INDEX_ADD;\n"
"}\n"
"}\n"
"}\n"
"#elif defined MASK_BINARY_OP\n"
"__kernel void KF(__global const uchar * srcptr1, int srcstep1, int srcoffset1,\n"
"__global const uchar * srcptr2, int srcstep2, int srcoffset2,\n"
"__global const uchar * mask, int maskstep, int maskoffset,\n"
"__global uchar * dstptr, int dststep, int dstoffset,\n"
"int rows, int cols EXTRA_PARAMS )\n"
"{\n"
"int x = get_global_id(0);\n"
"int y0 = get_global_id(1) * rowsPerWI;\n"
"if (x < cols)\n"
"{\n"
"int mask_index = mad24(y0, maskstep, x + maskoffset);\n"
"int src1_index = mad24(y0, srcstep1, mad24(x, (int)sizeof(srcT1_C1) * cn, srcoffset1));\n"
"int src2_index = mad24(y0, srcstep2, mad24(x, (int)sizeof(srcT2_C1) * cn, srcoffset2));\n"
"int dst_index = mad24(y0, dststep, mad24(x, (int)sizeof(dstT_C1) * cn, dstoffset));\n"
"for (int y = y0, y1 = min(rows, y0 + rowsPerWI); y < y1; ++y, src1_index += srcstep1, src2_index += srcstep2,\n"
"mask_index += maskstep, dst_index += dststep)\n"
"if (mask[mask_index])\n"
"{\n"
"PROCESS_ELEM;\n"
"}\n"
"}\n"
"}\n"
"#elif defined UNARY_OP\n"
"__kernel void KF(__global const uchar * srcptr1, int srcstep1, int srcoffset1,\n"
"__global uchar * dstptr, int dststep, int dstoffset,\n"
"int rows, int cols EXTRA_PARAMS )\n"
"{\n"
"int x = get_global_id(0);\n"
"int y0 = get_global_id(1) * rowsPerWI;\n"
"if (x < cols)\n"
"{\n"
"int src1_index = mad24(y0, srcstep1, mad24(x, (int)sizeof(srcT1_C1) * cn, srcoffset1));\n"
"int dst_index = mad24(y0, dststep, mad24(x, (int)sizeof(dstT_C1) * cn, dstoffset));\n"
"for (int y = y0, y1 = min(rows, y0 + rowsPerWI); y < y1; ++y, src1_index += srcstep1, dst_index += dststep)\n"
"{\n"
"PROCESS_ELEM;\n"
"}\n"
"}\n"
"}\n"
"#elif defined MASK_UNARY_OP\n"
"__kernel void KF(__global const uchar * srcptr1, int srcstep1, int srcoffset1,\n"
"__global const uchar * mask, int maskstep, int maskoffset,\n"
"__global uchar * dstptr, int dststep, int dstoffset,\n"
"int rows, int cols EXTRA_PARAMS )\n"
"{\n"
"int x = get_global_id(0);\n"
"int y0 = get_global_id(1) * rowsPerWI;\n"
"if (x < cols)\n"
"{\n"
"int mask_index = mad24(y0, maskstep, x + maskoffset);\n"
"int src1_index = mad24(y0, srcstep1, mad24(x, (int)sizeof(srcT1_C1) * cn, srcoffset1));\n"
"int dst_index = mad24(y0, dststep, mad24(x, (int)sizeof(dstT_C1) * cn, dstoffset));\n"
"for (int y = y0, y1 = min(rows, y0 + rowsPerWI); y < y1; ++y, src1_index += srcstep1, mask_index += maskstep, dst_index += dststep)\n"
"if (mask[mask_index])\n"
"{\n"
"PROCESS_ELEM;\n"
"}\n"
"}\n"
"}\n"
"#else\n"
"#error \"Unknown operation type\"\n"
"#endif\n"
, "ef162fc0076ff29b83ff3439b7949b9a", NULL};
struct cv::ocl::internal::ProgramEntry convert_oclsrc={moduleName, "convert",
"#ifdef DOUBLE_SUPPORT\n"
"#ifdef cl_amd_fp64\n"
"#pragma OPENCL EXTENSION cl_amd_fp64:enable\n"
"#elif defined (cl_khr_fp64)\n"
"#pragma OPENCL EXTENSION cl_khr_fp64:enable\n"
"#endif\n"
"#endif\n"
"#define noconvert\n"
"__kernel void convertTo(__global const uchar * srcptr, int src_step, int src_offset,\n"
"__global uchar * dstptr, int dst_step, int dst_offset, int dst_rows, int dst_cols,\n"
"#ifndef NO_SCALE\n"
"WT alpha, WT beta,\n"
"#endif\n"
"int rowsPerWI)\n"
"{\n"
"int x = get_global_id(0);\n"
"int y0 = get_global_id(1) * rowsPerWI;\n"
"if (x < dst_cols)\n"
"{\n"
"int src_index = mad24(y0, src_step, mad24(x, (int)sizeof(srcT), src_offset));\n"
"int dst_index = mad24(y0, dst_step, mad24(x, (int)sizeof(dstT), dst_offset));\n"
"for (int y = y0, y1 = min(dst_rows, y0 + rowsPerWI); y < y1; ++y, src_index += src_step, dst_index += dst_step)\n"
"{\n"
"__global const srcT * src = (__global const srcT *)(srcptr + src_index);\n"
"__global dstT * dst = (__global dstT *)(dstptr + dst_index);\n"
"#ifdef NO_SCALE\n"
"dst[0] = convertToDT(src[0]);\n"
"#else\n"
"dst[0] = convertToDT(fma(convertToWT(src[0]), alpha, beta));\n"
"#endif\n"
"}\n"
"}\n"
"}\n"
, "2e3d527cefb9468930dac19ffd9e28bd", NULL};
struct cv::ocl::internal::ProgramEntry copymakeborder_oclsrc={moduleName, "copymakeborder",
"#ifdef DOUBLE_SUPPORT\n"
"#ifdef cl_amd_fp64\n"
"#pragma OPENCL EXTENSION cl_amd_fp64:enable\n"
"#elif defined (cl_khr_fp64)\n"
"#pragma OPENCL EXTENSION cl_khr_fp64:enable\n"
"#endif\n"
"#endif\n"
"#if cn != 3\n"
"#define loadpix(addr) *(__global const T*)(addr)\n"
"#define storepix(val, addr) *(__global T*)(addr) = val\n"
"#define TSIZE ((int)sizeof(T))\n"
"#define convertScalar(a) (a)\n"
"#else\n"
"#define loadpix(addr) vload3(0, (__global const T1*)(addr))\n"
"#define storepix(val, addr) vstore3(val, 0, (__global T1*)(addr))\n"
"#define TSIZE ((int)sizeof(T1)*3)\n"
"#define convertScalar(a) (T)(a.x, a.y, a.z)\n"
"#endif\n"
"#ifdef BORDER_CONSTANT\n"
"#define EXTRAPOLATE(x, cols) \\\n"
";\n"
"#elif defined BORDER_REPLICATE\n"
"#define EXTRAPOLATE(x, cols) \\\n"
"x = clamp(x, 0, cols - 1);\n"
"#elif defined BORDER_WRAP\n"
"#define EXTRAPOLATE(x, cols) \\\n"
"{ \\\n"
"if (x < 0) \\\n"
"x -= ((x - cols + 1) / cols) * cols; \\\n"
"if (x >= cols) \\\n"
"x %= cols; \\\n"
"}\n"
"#elif defined(BORDER_REFLECT) || defined(BORDER_REFLECT_101)\n"
"#ifdef BORDER_REFLECT\n"
"#define DELTA int delta = 0\n"
"#else\n"
"#define DELTA int delta = 1\n"
"#endif\n"
"#define EXTRAPOLATE(x, cols) \\\n"
"{ \\\n"
"DELTA; \\\n"
"if (cols == 1) \\\n"
"x = 0; \\\n"
"else \\\n"
"do \\\n"
"{ \\\n"
"if( x < 0 ) \\\n"
"x = -x - 1 + delta; \\\n"
"else \\\n"
"x = cols - 1 - (x - cols) - delta; \\\n"
"} \\\n"
"while (x >= cols || x < 0); \\\n"
"}\n"
"#else\n"
"#error \"No extrapolation method\"\n"
"#endif\n"
"#define NEED_EXTRAPOLATION(x, cols) (x >= cols || x < 0)\n"
"__kernel void copyMakeBorder(__global const uchar * srcptr, int src_step, int src_offset, int src_rows, int src_cols,\n"
"__global uchar * dstptr, int dst_step, int dst_offset, int dst_rows, int dst_cols,\n"
"int top, int left, ST nVal)\n"
"{\n"
"int x = get_global_id(0);\n"
"int y0 = get_global_id(1) * rowsPerWI;\n"
"#ifdef BORDER_CONSTANT\n"
"T scalar = convertScalar(nVal);\n"
"#endif\n"
"if (x < dst_cols)\n"
"{\n"
"int src_x = x - left, src_y;\n"
"int dst_index = mad24(y0, dst_step, mad24(x, (int)TSIZE, dst_offset));\n"
"if (NEED_EXTRAPOLATION(src_x, src_cols))\n"
"{\n"
"#ifdef BORDER_CONSTANT\n"
"for (int y = y0, y1 = min(y0 + rowsPerWI, dst_rows); y < y1; ++y, dst_index += dst_step)\n"
"storepix(scalar, dstptr + dst_index);\n"
"return;\n"
"#endif\n"
"EXTRAPOLATE(src_x, src_cols)\n"
"}\n"
"src_x = mad24(src_x, TSIZE, src_offset);\n"
"for (int y = y0, y1 = min(y0 + rowsPerWI, dst_rows); y < y1; ++y, dst_index += dst_step)\n"
"{\n"
"src_y = y - top;\n"
"if (NEED_EXTRAPOLATION(src_y, src_rows))\n"
"{\n"
"EXTRAPOLATE(src_y, src_rows)\n"
"#ifdef BORDER_CONSTANT\n"
"storepix(scalar, dstptr + dst_index);\n"
"continue;\n"
"#endif\n"
"}\n"
"int src_index = mad24(src_y, src_step, src_x);\n"
"storepix(loadpix(srcptr + src_index), dstptr + dst_index);\n"
"}\n"
"}\n"
"}\n"
, "64f03714b8763ec6c2ac2f4b2ad0cf5d", NULL};
struct cv::ocl::internal::ProgramEntry copyset_oclsrc={moduleName, "copyset",
"#ifdef COPY_TO_MASK\n"
"#define DEFINE_DATA \\\n"
"int src_index = mad24(y, src_step, mad24(x, (int)sizeof(T1) * scn, src_offset)); \\\n"
"int dst_index = mad24(y, dst_step, mad24(x, (int)sizeof(T1) * scn, dst_offset)); \\\n"
"\\\n"
"__global const T1 * src = (__global const T1 *)(srcptr + src_index); \\\n"
"__global T1 * dst = (__global T1 *)(dstptr + dst_index)\n"
"__kernel void copyToMask(__global const uchar * srcptr, int src_step, int src_offset,\n"
"__global const uchar * mask, int mask_step, int mask_offset,\n"
"__global uchar * dstptr, int dst_step, int dst_offset,\n"
"int dst_rows, int dst_cols)\n"
"{\n"
"int x = get_global_id(0);\n"
"int y = get_global_id(1);\n"
"if (x < dst_cols && y < dst_rows)\n"
"{\n"
"mask += mad24(y, mask_step, mad24(x, mcn, mask_offset));\n"
"#if mcn == 1\n"
"if (mask[0])\n"
"{\n"
"DEFINE_DATA;\n"
"#pragma unroll\n"
"for (int c = 0; c < scn; ++c)\n"
"dst[c] = src[c];\n"
"}\n"
"#ifdef HAVE_DST_UNINIT\n"
"else\n"
"{\n"
"DEFINE_DATA;\n"
"#pragma unroll\n"
"for (int c = 0; c < scn; ++c)\n"
"dst[c] = (T1)(0);\n"
"}\n"
"#endif\n"
"#elif scn == mcn\n"
"DEFINE_DATA;\n"
"#pragma unroll\n"
"for (int c = 0; c < scn; ++c)\n"
"if (mask[c])\n"
"dst[c] = src[c];\n"
"#ifdef HAVE_DST_UNINIT\n"
"else\n"
"dst[c] = (T1)(0);\n"
"#endif\n"
"#else\n"
"#error \"(mcn == 1 || mcn == scn) should be true\"\n"
"#endif\n"
"}\n"
"}\n"
"#else\n"
"#ifndef dstST\n"
"#define dstST dstT\n"
"#endif\n"
"#if cn != 3\n"
"#define value value_\n"
"#define storedst(val) *(__global dstT *)(dstptr + dst_index) = val\n"
"#else\n"
"#define value (dstT)(value_.x, value_.y, value_.z)\n"
"#define storedst(val) vstore3(val, 0, (__global dstT1 *)(dstptr + dst_index))\n"
"#endif\n"
"__kernel void setMask(__global const uchar* mask, int maskstep, int maskoffset,\n"
"__global uchar* dstptr, int dststep, int dstoffset,\n"
"int rows, int cols, dstST value_)\n"
"{\n"
"int x = get_global_id(0);\n"
"int y0 = get_global_id(1) * rowsPerWI;\n"
"if (x < cols)\n"
"{\n"
"int mask_index = mad24(y0, maskstep, x + maskoffset);\n"
"int dst_index = mad24(y0, dststep, mad24(x, (int)sizeof(dstT1) * cn, dstoffset));\n"
"for (int y = y0, y1 = min(rows, y0 + rowsPerWI); y < y1; ++y)\n"
"{\n"
"if( mask[mask_index] )\n"
"storedst(value);\n"
"mask_index += maskstep;\n"
"dst_index += dststep;\n"
"}\n"
"}\n"
"}\n"
"__kernel void set(__global uchar* dstptr, int dststep, int dstoffset,\n"
"int rows, int cols, dstST value_)\n"
"{\n"
"int x = get_global_id(0);\n"
"int y0 = get_global_id(1) * rowsPerWI;\n"
"if (x < cols)\n"
"{\n"
"int dst_index = mad24(y0, dststep, mad24(x, (int)sizeof(dstT1) * cn, dstoffset));\n"
"for (int y = y0, y1 = min(rows, y0 + rowsPerWI); y < y1; ++y, dst_index += dststep)\n"
"storedst(value);\n"
"}\n"
"}\n"
"#endif\n"
, "f8f028f1776dc5c98bf03411d3b72318", NULL};
struct cv::ocl::internal::ProgramEntry cvtclr_dx_oclsrc={moduleName, "cvtclr_dx",
"#ifdef DOUBLE_SUPPORT\n"
"#ifdef cl_amd_fp64\n"
"#pragma OPENCL EXTENSION cl_amd_fp64:enable\n"
"#elif defined cl_khr_fp64\n"
"#pragma OPENCL EXTENSION cl_khr_fp64:enable\n"
"#endif\n"
"#endif\n"
"#ifdef INTEL_DEVICE\n"
"#pragma OPENCL FP_CONTRACT ON\n"
"#pragma OPENCL FP_FAST_FMAF ON\n"
"#pragma OPENCL FP_FAST_FMA ON\n"
"#endif\n"
"static\n"
"__constant\n"
"float c_YUV2RGBCoeffs_420[5] =\n"
"{\n"
"1.163999557f,\n"
"2.017999649f,\n"
"-0.390999794f,\n"
"-0.812999725f,\n"
"1.5959997177f\n"
"};\n"
"static const __constant float CV_8U_MAX = 255.0f;\n"
"static const __constant float CV_8U_HALF = 128.0f;\n"
"static const __constant float BT601_BLACK_RANGE = 16.0f;\n"
"static const __constant float CV_8U_SCALE = 1.0f / 255.0f;\n"
"static const __constant float d1 = BT601_BLACK_RANGE / CV_8U_MAX;\n"
"static const __constant float d2 = CV_8U_HALF / CV_8U_MAX;\n"
"#define NCHANNELS 3\n"
"__kernel\n"
"void YUV2BGR_NV12_8u(\n"
"read_only image2d_t imgY,\n"
"read_only image2d_t imgUV,\n"
"__global unsigned char* pBGR,\n"
"int bgrStep,\n"
"int cols,\n"
"int rows)\n"
"{\n"
"int x = get_global_id(0);\n"
"int y = get_global_id(1);\n"
"int x2 = x*2;\n"
"int y2 = y*2;\n"
"if (x2 + 1 < cols) {\n"
"if (y2 + 1 < rows) {\n"
"__global uchar *pDstRow1 = pBGR + mad24(y2, bgrStep, mad24(x2, NCHANNELS, 0));\n"
"__global uchar *pDstRow2 = pDstRow1 + bgrStep;\n"
"float4 Y1 = read_imagef(imgY, (int2)(x2 + 0, y2 + 0));\n"
"float4 Y2 = read_imagef(imgY, (int2)(x2 + 1, y2 + 0));\n"
"float4 Y3 = read_imagef(imgY, (int2)(x2 + 0, y2 + 1));\n"
"float4 Y4 = read_imagef(imgY, (int2)(x2 + 1, y2 + 1));\n"
"float4 Y = (float4)(Y1.x, Y2.x, Y3.x, Y4.x);\n"
"float4 UV = read_imagef(imgUV, (int2)(x, y)) - d2;\n"
"__constant float *coeffs = c_YUV2RGBCoeffs_420;\n"
"Y = max(0.f, Y - d1) * coeffs[0];\n"
"float ruv = fma(coeffs[4], UV.y, 0.0f);\n"
"float guv = fma(coeffs[3], UV.y, fma(coeffs[2], UV.x, 0.0f));\n"
"float buv = fma(coeffs[1], UV.x, 0.0f);\n"
"float4 R = (Y + ruv) * CV_8U_MAX;\n"
"float4 G = (Y + guv) * CV_8U_MAX;\n"
"float4 B = (Y + buv) * CV_8U_MAX;\n"
"pDstRow1[0*NCHANNELS + 0] = convert_uchar_sat(B.x);\n"
"pDstRow1[0*NCHANNELS + 1] = convert_uchar_sat(G.x);\n"
"pDstRow1[0*NCHANNELS + 2] = convert_uchar_sat(R.x);\n"
"pDstRow1[1*NCHANNELS + 0] = convert_uchar_sat(B.y);\n"
"pDstRow1[1*NCHANNELS + 1] = convert_uchar_sat(G.y);\n"
"pDstRow1[1*NCHANNELS + 2] = convert_uchar_sat(R.y);\n"
"pDstRow2[0*NCHANNELS + 0] = convert_uchar_sat(B.z);\n"
"pDstRow2[0*NCHANNELS + 1] = convert_uchar_sat(G.z);\n"
"pDstRow2[0*NCHANNELS + 2] = convert_uchar_sat(R.z);\n"
"pDstRow2[1*NCHANNELS + 0] = convert_uchar_sat(B.w);\n"
"pDstRow2[1*NCHANNELS + 1] = convert_uchar_sat(G.w);\n"
"pDstRow2[1*NCHANNELS + 2] = convert_uchar_sat(R.w);\n"
"}\n"
"}\n"
"}\n"
"static\n"
"__constant float c_RGB2YUVCoeffs_420[8] =\n"
"{\n"
"0.256999969f, 0.50399971f, 0.09799957f, -0.1479988098f,\n"
"-0.2909994125f, 0.438999176f, -0.3679990768f, -0.0709991455f\n"
"};\n"
"__kernel\n"
"void BGR2YUV_NV12_8u(\n"
"__global unsigned char* pBGR,\n"
"int bgrStep,\n"
"int cols,\n"
"int rows,\n"
"write_only image2d_t imgY,\n"
"write_only image2d_t imgUV)\n"
"{\n"
"int x = get_global_id(0);\n"
"int y = get_global_id(1);\n"
"int x2 = x*2;\n"
"int y2 = y*2;\n"
"if (x2 + 1 < cols)\n"
"{\n"
"if (y2 + 1 < rows)\n"
"{\n"
"__global const uchar* pSrcRow1 = pBGR + mad24(y2, bgrStep, mad24(x2, NCHANNELS, 0));\n"
"__global const uchar* pSrcRow2 = pSrcRow1 + bgrStep;\n"
"float4 src_pix1 = convert_float4(vload4(0, pSrcRow1 + 0*NCHANNELS)) * CV_8U_SCALE;\n"
"float4 src_pix2 = convert_float4(vload4(0, pSrcRow1 + 1*NCHANNELS)) * CV_8U_SCALE;\n"
"float4 src_pix3 = convert_float4(vload4(0, pSrcRow2 + 0*NCHANNELS)) * CV_8U_SCALE;\n"
"float4 src_pix4 = convert_float4(vload4(0, pSrcRow2 + 1*NCHANNELS)) * CV_8U_SCALE;\n"
"__constant float* coeffs = c_RGB2YUVCoeffs_420;\n"
"float Y1 = fma(coeffs[0], src_pix1.z, fma(coeffs[1], src_pix1.y, fma(coeffs[2], src_pix1.x, d1)));\n"
"float Y2 = fma(coeffs[0], src_pix2.z, fma(coeffs[1], src_pix2.y, fma(coeffs[2], src_pix2.x, d1)));\n"
"float Y3 = fma(coeffs[0], src_pix3.z, fma(coeffs[1], src_pix3.y, fma(coeffs[2], src_pix3.x, d1)));\n"
"float Y4 = fma(coeffs[0], src_pix4.z, fma(coeffs[1], src_pix4.y, fma(coeffs[2], src_pix4.x, d1)));\n"
"float4 UV;\n"
"UV.x = fma(coeffs[3], src_pix1.z, fma(coeffs[4], src_pix1.y, fma(coeffs[5], src_pix1.x, d2)));\n"
"UV.y = fma(coeffs[5], src_pix1.z, fma(coeffs[6], src_pix1.y, fma(coeffs[7], src_pix1.x, d2)));\n"
"write_imagef(imgY, (int2)(x2+0, y2+0), Y1);\n"
"write_imagef(imgY, (int2)(x2+1, y2+0), Y2);\n"
"write_imagef(imgY, (int2)(x2+0, y2+1), Y3);\n"
"write_imagef(imgY, (int2)(x2+1, y2+1), Y4);\n"
"write_imagef(imgUV, (int2)(x, y), UV);\n"
"}\n"
"}\n"
"}\n"
, "6f6a1321f275b328ee827cc87cb40fa1", NULL};
struct cv::ocl::internal::ProgramEntry fft_oclsrc={moduleName, "fft",
"#define SQRT_2 0.707106781188f\n"
"#define sin_120 0.866025403784f\n"
"#define fft5_2 0.559016994374f\n"
"#define fft5_3 -0.951056516295f\n"
"#define fft5_4 -1.538841768587f\n"
"#define fft5_5 0.363271264002f\n"
"#ifdef DOUBLE_SUPPORT\n"
"#ifdef cl_amd_fp64\n"
"#pragma OPENCL EXTENSION cl_amd_fp64:enable\n"
"#elif defined (cl_khr_fp64)\n"
"#pragma OPENCL EXTENSION cl_khr_fp64:enable\n"
"#endif\n"
"#endif\n"
"__attribute__((always_inline))\n"
"CT mul_complex(CT a, CT b) {\n"
"return (CT)(fma(a.x, b.x, -a.y * b.y), fma(a.x, b.y, a.y * b.x));\n"
"}\n"
"__attribute__((always_inline))\n"
"CT twiddle(CT a) {\n"
"return (CT)(a.y, -a.x);\n"
"}\n"
"__attribute__((always_inline))\n"
"void butterfly2(CT a0, CT a1, __local CT* smem, __global const CT* twiddles,\n"
"const int x, const int block_size)\n"
"{\n"
"const int k = x & (block_size - 1);\n"
"a1 = mul_complex(twiddles[k], a1);\n"
"const int dst_ind = (x << 1) - k;\n"
"smem[dst_ind] = a0 + a1;\n"
"smem[dst_ind+block_size] = a0 - a1;\n"
"}\n"
"__attribute__((always_inline))\n"
"void butterfly4(CT a0, CT a1, CT a2, CT a3, __local CT* smem, __global const CT* twiddles,\n"
"const int x, const int block_size)\n"
"{\n"
"const int k = x & (block_size - 1);\n"
"a1 = mul_complex(twiddles[k], a1);\n"
"a2 = mul_complex(twiddles[k + block_size], a2);\n"
"a3 = mul_complex(twiddles[k + 2*block_size], a3);\n"
"const int dst_ind = ((x - k) << 2) + k;\n"
"CT b0 = a0 + a2;\n"
"a2 = a0 - a2;\n"
"CT b1 = a1 + a3;\n"
"a3 = twiddle(a1 - a3);\n"
"smem[dst_ind] = b0 + b1;\n"
"smem[dst_ind + block_size] = a2 + a3;\n"
"smem[dst_ind + 2*block_size] = b0 - b1;\n"
"smem[dst_ind + 3*block_size] = a2 - a3;\n"
"}\n"
"__attribute__((always_inline))\n"
"void butterfly3(CT a0, CT a1, CT a2, __local CT* smem, __global const CT* twiddles,\n"
"const int x, const int block_size)\n"
"{\n"
"const int k = x % block_size;\n"
"a1 = mul_complex(twiddles[k], a1);\n"
"a2 = mul_complex(twiddles[k+block_size], a2);\n"
"const int dst_ind = ((x - k) * 3) + k;\n"
"CT b1 = a1 + a2;\n"
"a2 = twiddle(sin_120*(a1 - a2));\n"
"CT b0 = a0 - (CT)(0.5f)*b1;\n"
"smem[dst_ind] = a0 + b1;\n"
"smem[dst_ind + block_size] = b0 + a2;\n"
"smem[dst_ind + 2*block_size] = b0 - a2;\n"
"}\n"
"__attribute__((always_inline))\n"
"void butterfly5(CT a0, CT a1, CT a2, CT a3, CT a4, __local CT* smem, __global const CT* twiddles,\n"
"const int x, const int block_size)\n"
"{\n"
"const int k = x % block_size;\n"
"a1 = mul_complex(twiddles[k], a1);\n"
"a2 = mul_complex(twiddles[k + block_size], a2);\n"
"a3 = mul_complex(twiddles[k+2*block_size], a3);\n"
"a4 = mul_complex(twiddles[k+3*block_size], a4);\n"
"const int dst_ind = ((x - k) * 5) + k;\n"
"__local CT* dst = smem + dst_ind;\n"
"CT b0, b1, b5;\n"
"b1 = a1 + a4;\n"
"a1 -= a4;\n"
"a4 = a3 + a2;\n"
"a3 -= a2;\n"
"a2 = b1 + a4;\n"
"b0 = a0 - (CT)0.25f * a2;\n"
"b1 = fft5_2 * (b1 - a4);\n"
"a4 = fft5_3 * (CT)(-a1.y - a3.y, a1.x + a3.x);\n"
"b5 = (CT)(a4.x - fft5_5 * a1.y, a4.y + fft5_5 * a1.x);\n"
"a4.x += fft5_4 * a3.y;\n"
"a4.y -= fft5_4 * a3.x;\n"
"a1 = b0 + b1;\n"
"b0 -= b1;\n"
"dst[0] = a0 + a2;\n"
"dst[block_size] = a1 + a4;\n"
"dst[2 * block_size] = b0 + b5;\n"
"dst[3 * block_size] = b0 - b5;\n"
"dst[4 * block_size] = a1 - a4;\n"
"}\n"
"__attribute__((always_inline))\n"
"void fft_radix2(__local CT* smem, __global const CT* twiddles, const int x, const int block_size, const int t)\n"
"{\n"
"CT a0, a1;\n"
"if (x < t)\n"
"{\n"
"a0 = smem[x];\n"
"a1 = smem[x+t];\n"
"}\n"
"barrier(CLK_LOCAL_MEM_FENCE);\n"
"if (x < t)\n"
"butterfly2(a0, a1, smem, twiddles, x, block_size);\n"
"barrier(CLK_LOCAL_MEM_FENCE);\n"
"}\n"
"__attribute__((always_inline))\n"
"void fft_radix2_B2(__local CT* smem, __global const CT* twiddles, const int x1, const int block_size, const int t)\n"
"{\n"
"const int x2 = x1 + t/2;\n"
"CT a0, a1, a2, a3;\n"
"if (x1 < t/2)\n"
"{\n"
"a0 = smem[x1]; a1 = smem[x1+t];\n"
"a2 = smem[x2]; a3 = smem[x2+t];\n"
"}\n"
"barrier(CLK_LOCAL_MEM_FENCE);\n"
"if (x1 < t/2)\n"
"{\n"
"butterfly2(a0, a1, smem, twiddles, x1, block_size);\n"
"butterfly2(a2, a3, smem, twiddles, x2, block_size);\n"
"}\n"
"barrier(CLK_LOCAL_MEM_FENCE);\n"
"}\n"
"__attribute__((always_inline))\n"
"void fft_radix2_B3(__local CT* smem, __global const CT* twiddles, const int x1, const int block_size, const int t)\n"
"{\n"
"const int x2 = x1 + t/3;\n"
"const int x3 = x1 + 2*t/3;\n"
"CT a0, a1, a2, a3, a4, a5;\n"
"if (x1 < t/3)\n"
"{\n"
"a0 = smem[x1]; a1 = smem[x1+t];\n"
"a2 = smem[x2]; a3 = smem[x2+t];\n"
"a4 = smem[x3]; a5 = smem[x3+t];\n"
"}\n"
"barrier(CLK_LOCAL_MEM_FENCE);\n"
"if (x1 < t/3)\n"
"{\n"
"butterfly2(a0, a1, smem, twiddles, x1, block_size);\n"
"butterfly2(a2, a3, smem, twiddles, x2, block_size);\n"
"butterfly2(a4, a5, smem, twiddles, x3, block_size);\n"
"}\n"
"barrier(CLK_LOCAL_MEM_FENCE);\n"
"}\n"
"__attribute__((always_inline))\n"
"void fft_radix2_B4(__local CT* smem, __global const CT* twiddles, const int x1, const int block_size, const int t)\n"
"{\n"
"const int thread_block = t/4;\n"
"const int x2 = x1 + thread_block;\n"
"const int x3 = x1 + 2*thread_block;\n"
"const int x4 = x1 + 3*thread_block;\n"
"CT a0, a1, a2, a3, a4, a5, a6, a7;\n"
"if (x1 < t/4)\n"
"{\n"
"a0 = smem[x1]; a1 = smem[x1+t];\n"
"a2 = smem[x2]; a3 = smem[x2+t];\n"
"a4 = smem[x3]; a5 = smem[x3+t];\n"
"a6 = smem[x4]; a7 = smem[x4+t];\n"
"}\n"
"barrier(CLK_LOCAL_MEM_FENCE);\n"
"if (x1 < t/4)\n"
"{\n"
"butterfly2(a0, a1, smem, twiddles, x1, block_size);\n"
"butterfly2(a2, a3, smem, twiddles, x2, block_size);\n"
"butterfly2(a4, a5, smem, twiddles, x3, block_size);\n"
"butterfly2(a6, a7, smem, twiddles, x4, block_size);\n"
"}\n"
"barrier(CLK_LOCAL_MEM_FENCE);\n"
"}\n"
"__attribute__((always_inline))\n"
"void fft_radix2_B5(__local CT* smem, __global const CT* twiddles, const int x1, const int block_size, const int t)\n"
"{\n"
"const int thread_block = t/5;\n"
"const int x2 = x1 + thread_block;\n"
"const int x3 = x1 + 2*thread_block;\n"
"const int x4 = x1 + 3*thread_block;\n"
"const int x5 = x1 + 4*thread_block;\n"
"CT a0, a1, a2, a3, a4, a5, a6, a7, a8, a9;\n"
"if (x1 < t/5)\n"
"{\n"
"a0 = smem[x1]; a1 = smem[x1+t];\n"
"a2 = smem[x2]; a3 = smem[x2+t];\n"
"a4 = smem[x3]; a5 = smem[x3+t];\n"
"a6 = smem[x4]; a7 = smem[x4+t];\n"
"a8 = smem[x5]; a9 = smem[x5+t];\n"
"}\n"
"barrier(CLK_LOCAL_MEM_FENCE);\n"
"if (x1 < t/5)\n"
"{\n"
"butterfly2(a0, a1, smem, twiddles, x1, block_size);\n"
"butterfly2(a2, a3, smem, twiddles, x2, block_size);\n"
"butterfly2(a4, a5, smem, twiddles, x3, block_size);\n"
"butterfly2(a6, a7, smem, twiddles, x4, block_size);\n"
"butterfly2(a8, a9, smem, twiddles, x5, block_size);\n"
"}\n"
"barrier(CLK_LOCAL_MEM_FENCE);\n"
"}\n"
"__attribute__((always_inline))\n"
"void fft_radix4(__local CT* smem, __global const CT* twiddles, const int x, const int block_size, const int t)\n"
"{\n"
"CT a0, a1, a2, a3;\n"
"if (x < t)\n"
"{\n"
"a0 = smem[x]; a1 = smem[x+t]; a2 = smem[x+2*t]; a3 = smem[x+3*t];\n"
"}\n"
"barrier(CLK_LOCAL_MEM_FENCE);\n"
"if (x < t)\n"
"butterfly4(a0, a1, a2, a3, smem, twiddles, x, block_size);\n"
"barrier(CLK_LOCAL_MEM_FENCE);\n"
"}\n"
"__attribute__((always_inline))\n"
"void fft_radix4_B2(__local CT* smem, __global const CT* twiddles, const int x1, const int block_size, const int t)\n"
"{\n"
"const int x2 = x1 + t/2;\n"
"CT a0, a1, a2, a3, a4, a5, a6, a7;\n"
"if (x1 < t/2)\n"
"{\n"
"a0 = smem[x1]; a1 = smem[x1+t]; a2 = smem[x1+2*t]; a3 = smem[x1+3*t];\n"
"a4 = smem[x2]; a5 = smem[x2+t]; a6 = smem[x2+2*t]; a7 = smem[x2+3*t];\n"
"}\n"
"barrier(CLK_LOCAL_MEM_FENCE);\n"
"if (x1 < t/2)\n"
"{\n"
"butterfly4(a0, a1, a2, a3, smem, twiddles, x1, block_size);\n"
"butterfly4(a4, a5, a6, a7, smem, twiddles, x2, block_size);\n"
"}\n"
"barrier(CLK_LOCAL_MEM_FENCE);\n"
"}\n"
"__attribute__((always_inline))\n"
"void fft_radix4_B3(__local CT* smem, __global const CT* twiddles, const int x1, const int block_size, const int t)\n"
"{\n"
"const int x2 = x1 + t/3;\n"
"const int x3 = x2 + t/3;\n"
"CT a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11;\n"
"if (x1 < t/3)\n"
"{\n"
"a0 = smem[x1]; a1 = smem[x1+t]; a2 = smem[x1+2*t]; a3 = smem[x1+3*t];\n"
"a4 = smem[x2]; a5 = smem[x2+t]; a6 = smem[x2+2*t]; a7 = smem[x2+3*t];\n"
"a8 = smem[x3]; a9 = smem[x3+t]; a10 = smem[x3+2*t]; a11 = smem[x3+3*t];\n"
"}\n"
"barrier(CLK_LOCAL_MEM_FENCE);\n"
"if (x1 < t/3)\n"
"{\n"
"butterfly4(a0, a1, a2, a3, smem, twiddles, x1, block_size);\n"
"butterfly4(a4, a5, a6, a7, smem, twiddles, x2, block_size);\n"
"butterfly4(a8, a9, a10, a11, smem, twiddles, x3, block_size);\n"
"}\n"
"barrier(CLK_LOCAL_MEM_FENCE);\n"
"}\n"
"__attribute__((always_inline))\n"
"void fft_radix8(__local CT* smem, __global const CT* twiddles, const int x, const int block_size, const int t)\n"
"{\n"
"const int k = x % block_size;\n"
"CT a0, a1, a2, a3, a4, a5, a6, a7;\n"
"if (x < t)\n"
"{\n"
"int tw_ind = block_size / 8;\n"
"a0 = smem[x];\n"
"a1 = mul_complex(twiddles[k], smem[x + t]);\n"
"a2 = mul_complex(twiddles[k + block_size],smem[x+2*t]);\n"
"a3 = mul_complex(twiddles[k+2*block_size],smem[x+3*t]);\n"
"a4 = mul_complex(twiddles[k+3*block_size],smem[x+4*t]);\n"
"a5 = mul_complex(twiddles[k+4*block_size],smem[x+5*t]);\n"
"a6 = mul_complex(twiddles[k+5*block_size],smem[x+6*t]);\n"
"a7 = mul_complex(twiddles[k+6*block_size],smem[x+7*t]);\n"
"CT b0, b1, b6, b7;\n"
"b0 = a0 + a4;\n"
"a4 = a0 - a4;\n"
"b1 = a1 + a5;\n"
"a5 = a1 - a5;\n"
"a5 = (CT)(SQRT_2) * (CT)(a5.x + a5.y, -a5.x + a5.y);\n"
"b6 = twiddle(a2 - a6);\n"
"a2 = a2 + a6;\n"
"b7 = a3 - a7;\n"
"b7 = (CT)(SQRT_2) * (CT)(-b7.x + b7.y, -b7.x - b7.y);\n"
"a3 = a3 + a7;\n"
"a0 = b0 + a2;\n"
"a2 = b0 - a2;\n"
"a1 = b1 + a3;\n"
"a3 = twiddle(b1 - a3);\n"
"a6 = a4 - b6;\n"
"a4 = a4 + b6;\n"
"a7 = twiddle(a5 - b7);\n"
"a5 = a5 + b7;\n"
"}\n"
"barrier(CLK_LOCAL_MEM_FENCE);\n"
"if (x < t)\n"
"{\n"
"const int dst_ind = ((x - k) << 3) + k;\n"
"__local CT* dst = smem + dst_ind;\n"
"dst[0] = a0 + a1;\n"
"dst[block_size] = a4 + a5;\n"
"dst[2 * block_size] = a2 + a3;\n"
"dst[3 * block_size] = a6 + a7;\n"
"dst[4 * block_size] = a0 - a1;\n"
"dst[5 * block_size] = a4 - a5;\n"
"dst[6 * block_size] = a2 - a3;\n"
"dst[7 * block_size] = a6 - a7;\n"
"}\n"
"barrier(CLK_LOCAL_MEM_FENCE);\n"
"}\n"
"__attribute__((always_inline))\n"
"void fft_radix3(__local CT* smem, __global const CT* twiddles, const int x, const int block_size, const int t)\n"
"{\n"
"CT a0, a1, a2;\n"
"if (x < t)\n"
"{\n"
"a0 = smem[x]; a1 = smem[x+t]; a2 = smem[x+2*t];\n"
"}\n"
"barrier(CLK_LOCAL_MEM_FENCE);\n"
"if (x < t)\n"
"butterfly3(a0, a1, a2, smem, twiddles, x, block_size);\n"
"barrier(CLK_LOCAL_MEM_FENCE);\n"
"}\n"
"__attribute__((always_inline))\n"
"void fft_radix3_B2(__local CT* smem, __global const CT* twiddles, const int x1, const int block_size, const int t)\n"
"{\n"
"const int x2 = x1 + t/2;\n"
"CT a0, a1, a2, a3, a4, a5;\n"
"if (x1 < t/2)\n"
"{\n"
"a0 = smem[x1]; a1 = smem[x1+t]; a2 = smem[x1+2*t];\n"
"a3 = smem[x2]; a4 = smem[x2+t]; a5 = smem[x2+2*t];\n"
"}\n"
"barrier(CLK_LOCAL_MEM_FENCE);\n"
"if (x1 < t/2)\n"
"{\n"
"butterfly3(a0, a1, a2, smem, twiddles, x1, block_size);\n"
"butterfly3(a3, a4, a5, smem, twiddles, x2, block_size);\n"
"}\n"
"barrier(CLK_LOCAL_MEM_FENCE);\n"
"}\n"
"__attribute__((always_inline))\n"
"void fft_radix3_B3(__local CT* smem, __global const CT* twiddles, const int x1, const int block_size, const int t)\n"
"{\n"
"const int x2 = x1 + t/3;\n"
"const int x3 = x2 + t/3;\n"
"CT a0, a1, a2, a3, a4, a5, a6, a7, a8;\n"
"if (x1 < t/3)\n"
"{\n"
"a0 = smem[x1]; a1 = smem[x1+t]; a2 = smem[x1+2*t];\n"
"a3 = smem[x2]; a4 = smem[x2+t]; a5 = smem[x2+2*t];\n"
"a6 = smem[x3]; a7 = smem[x3+t]; a8 = smem[x3+2*t];\n"
"}\n"
"barrier(CLK_LOCAL_MEM_FENCE);\n"
"if (x1 < t/3)\n"
"{\n"
"butterfly3(a0, a1, a2, smem, twiddles, x1, block_size);\n"
"butterfly3(a3, a4, a5, smem, twiddles, x2, block_size);\n"
"butterfly3(a6, a7, a8, smem, twiddles, x3, block_size);\n"
"}\n"
"barrier(CLK_LOCAL_MEM_FENCE);\n"
"}\n"
"__attribute__((always_inline))\n"
"void fft_radix3_B4(__local CT* smem, __global const CT* twiddles, const int x1, const int block_size, const int t)\n"
"{\n"
"const int thread_block = t/4;\n"
"const int x2 = x1 + thread_block;\n"
"const int x3 = x1 + 2*thread_block;\n"
"const int x4 = x1 + 3*thread_block;\n"
"CT a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11;\n"
"if (x1 < t/4)\n"
"{\n"
"a0 = smem[x1]; a1 = smem[x1+t]; a2 = smem[x1+2*t];\n"
"a3 = smem[x2]; a4 = smem[x2+t]; a5 = smem[x2+2*t];\n"
"a6 = smem[x3]; a7 = smem[x3+t]; a8 = smem[x3+2*t];\n"
"a9 = smem[x4]; a10 = smem[x4+t]; a11 = smem[x4+2*t];\n"
"}\n"
"barrier(CLK_LOCAL_MEM_FENCE);\n"
"if (x1 < t/4)\n"
"{\n"
"butterfly3(a0, a1, a2, smem, twiddles, x1, block_size);\n"
"butterfly3(a3, a4, a5, smem, twiddles, x2, block_size);\n"
"butterfly3(a6, a7, a8, smem, twiddles, x3, block_size);\n"
"butterfly3(a9, a10, a11, smem, twiddles, x4, block_size);\n"
"}\n"
"barrier(CLK_LOCAL_MEM_FENCE);\n"
"}\n"
"__attribute__((always_inline))\n"
"void fft_radix5(__local CT* smem, __global const CT* twiddles, const int x, const int block_size, const int t)\n"
"{\n"
"const int k = x % block_size;\n"
"CT a0, a1, a2, a3, a4;\n"
"if (x < t)\n"
"{\n"
"a0 = smem[x]; a1 = smem[x + t]; a2 = smem[x+2*t]; a3 = smem[x+3*t]; a4 = smem[x+4*t];\n"
"}\n"
"barrier(CLK_LOCAL_MEM_FENCE);\n"
"if (x < t)\n"
"butterfly5(a0, a1, a2, a3, a4, smem, twiddles, x, block_size);\n"
"barrier(CLK_LOCAL_MEM_FENCE);\n"
"}\n"
"__attribute__((always_inline))\n"
"void fft_radix5_B2(__local CT* smem, __global const CT* twiddles, const int x1, const int block_size, const int t)\n"
"{\n"
"const int x2 = x1+t/2;\n"
"CT a0, a1, a2, a3, a4, a5, a6, a7, a8, a9;\n"
"if (x1 < t/2)\n"
"{\n"
"a0 = smem[x1]; a1 = smem[x1 + t]; a2 = smem[x1+2*t]; a3 = smem[x1+3*t]; a4 = smem[x1+4*t];\n"
"a5 = smem[x2]; a6 = smem[x2 + t]; a7 = smem[x2+2*t]; a8 = smem[x2+3*t]; a9 = smem[x2+4*t];\n"
"}\n"
"barrier(CLK_LOCAL_MEM_FENCE);\n"
"if (x1 < t/2)\n"
"{\n"
"butterfly5(a0, a1, a2, a3, a4, smem, twiddles, x1, block_size);\n"
"butterfly5(a5, a6, a7, a8, a9, smem, twiddles, x2, block_size);\n"
"}\n"
"barrier(CLK_LOCAL_MEM_FENCE);\n"
"}\n"
"#ifdef DFT_SCALE\n"
"#define SCALE_VAL(x, scale) x*scale\n"
"#else\n"
"#define SCALE_VAL(x, scale) x\n"
"#endif\n"
"__kernel void fft_multi_radix_rows(__global const uchar* src_ptr, int src_step, int src_offset, int src_rows, int src_cols,\n"
"__global uchar* dst_ptr, int dst_step, int dst_offset, int dst_rows, int dst_cols,\n"
"__global CT* twiddles_ptr, int twiddles_step, int twiddles_offset, const int t, const int nz)\n"
"{\n"
"const int x = get_global_id(0);\n"
"const int y = get_group_id(1);\n"
"const int block_size = LOCAL_SIZE/kercn;\n"
"__local CT smem[LOCAL_SIZE];\n"
"if (y < nz)\n"
"{\n"
"__global const CT* twiddles = (__global const CT*)(twiddles_ptr + twiddles_offset);\n"
"const int ind = x;\n"
"#ifdef IS_1D\n"
"FT scale = (FT) 1/dst_cols;\n"
"#else\n"
"FT scale = (FT) 1/(dst_cols*dst_rows);\n"
"#endif\n"
"#ifdef COMPLEX_INPUT\n"
"__global const CT* src = (__global const CT*)(src_ptr + mad24(y, src_step, mad24(x, (int)(sizeof(CT)), src_offset)));\n"
"#pragma unroll\n"
"for (int i=0; i<kercn; i++)\n"
"smem[x+i*block_size] = src[i*block_size];\n"
"#else\n"
"__global const FT* src = (__global const FT*)(src_ptr + mad24(y, src_step, mad24(x, (int)sizeof(FT), src_offset)));\n"
"#pragma unroll\n"
"for (int i=0; i<kercn; i++)\n"
"smem[x+i*block_size] = (CT)(src[i*block_size], 0.f);\n"
"#endif\n"
"barrier(CLK_LOCAL_MEM_FENCE);\n"
"RADIX_PROCESS;\n"
"#ifdef COMPLEX_OUTPUT\n"
"#ifdef NO_CONJUGATE\n"
"const int cols = dst_cols/2 + 1;\n"
"#else\n"
"const int cols = dst_cols;\n"
"#endif\n"
"__global CT* dst = (__global CT*)(dst_ptr + mad24(y, dst_step, dst_offset));\n"
"#pragma unroll\n"
"for (int i=x; i<cols; i+=block_size)\n"
"dst[i] = SCALE_VAL(smem[i], scale);\n"
"#ifdef REAL_INPUT\n"
"#ifdef COMPLEX_OUTPUT\n"
"#ifdef IS_1D\n"
"for(int i=x+1; i < (dst_cols+1)/2; i+=block_size)\n"
"{\n"
"dst[dst_cols-i] = (CT)(SCALE_VAL(smem[i].x, scale), SCALE_VAL(-smem[i].y, scale));\n"
"}\n"
"#endif\n"
"#endif\n"
"#endif\n"
"#else\n"
"__local FT* smem_1cn = (__local FT*) smem;\n"
"__global FT* dst = (__global FT*)(dst_ptr + mad24(y, dst_step, dst_offset));\n"
"for (int i=x; i<dst_cols-1; i+=block_size)\n"
"dst[i+1] = SCALE_VAL(smem_1cn[i+2], scale);\n"
"if (x == 0)\n"
"dst[0] = SCALE_VAL(smem_1cn[0], scale);\n"
"#endif\n"
"}\n"
"else\n"
"{\n"
"#ifdef COMPLEX_OUTPUT\n"
"__global CT* dst = (__global CT*)(dst_ptr + mad24(y, dst_step, dst_offset));\n"
"#else\n"
"__global FT* dst = (__global FT*)(dst_ptr + mad24(y, dst_step, dst_offset));\n"
"#endif\n"
"#pragma unroll\n"
"for (int i=x; i<dst_cols; i+=block_size)\n"
"dst[i] = 0.f;\n"
"}\n"
"}\n"
"__kernel void fft_multi_radix_cols(__global const uchar* src_ptr, int src_step, int src_offset, int src_rows, int src_cols,\n"
"__global uchar* dst_ptr, int dst_step, int dst_offset, int dst_rows, int dst_cols,\n"
"__global CT* twiddles_ptr, int twiddles_step, int twiddles_offset, const int t, const int nz)\n"
"{\n"
"const int x = get_group_id(0);\n"
"const int y = get_global_id(1);\n"
"__local CT smem[LOCAL_SIZE];\n"
"if (x < nz)\n"
"{\n"
"__global const uchar* src = src_ptr + mad24(y, src_step, mad24(x, (int)(sizeof(CT)), src_offset));\n"
"__global const CT* twiddles = (__global const CT*)(twiddles_ptr + twiddles_offset);\n"
"const int ind = y;\n"
"const int block_size = LOCAL_SIZE/kercn;\n"
"FT scale = 1.f/(dst_rows*dst_cols);\n"
"#pragma unroll\n"
"for (int i=0; i<kercn; i++)\n"
"smem[y+i*block_size] = *((__global const CT*)(src + i*block_size*src_step));\n"
"barrier(CLK_LOCAL_MEM_FENCE);\n"
"RADIX_PROCESS;\n"
"#ifdef COMPLEX_OUTPUT\n"
"__global uchar* dst = dst_ptr + mad24(y, dst_step, mad24(x, (int)(sizeof(CT)), dst_offset));\n"
"#pragma unroll\n"
"for (int i=0; i<kercn; i++)\n"
"*((__global CT*)(dst + i*block_size*dst_step)) = SCALE_VAL(smem[y + i*block_size], scale);\n"
"#else\n"
"if (x == 0)\n"
"{\n"
"__local FT* smem_1cn = (__local FT*) smem;\n"
"__global uchar* dst = dst_ptr + mad24(y+1, dst_step, dst_offset);\n"
"for (int i=y; i<dst_rows-1; i+=block_size, dst+=dst_step*block_size)\n"
"*((__global FT*) dst) = SCALE_VAL(smem_1cn[i+2], scale);\n"
"if (y == 0)\n"
"*((__global FT*) (dst_ptr + dst_offset)) = SCALE_VAL(smem_1cn[0], scale);\n"
"}\n"
"else if (x == (dst_cols+1)/2)\n"
"{\n"
"__local FT* smem_1cn = (__local FT*) smem;\n"
"__global uchar* dst = dst_ptr + mad24(dst_cols-1, (int)sizeof(FT), mad24(y+1, dst_step, dst_offset));\n"
"for (int i=y; i<dst_rows-1; i+=block_size, dst+=dst_step*block_size)\n"
"*((__global FT*) dst) = SCALE_VAL(smem_1cn[i+2], scale);\n"
"if (y == 0)\n"
"*((__global FT*) (dst_ptr + mad24(dst_cols-1, (int)sizeof(FT), dst_offset))) = SCALE_VAL(smem_1cn[0], scale);\n"
"}\n"
"else\n"
"{\n"
"__global uchar* dst = dst_ptr + mad24(x, (int)sizeof(FT)*2, mad24(y, dst_step, dst_offset - (int)sizeof(FT)));\n"
"#pragma unroll\n"
"for (int i=y; i<dst_rows; i+=block_size, dst+=block_size*dst_step)\n"
"vstore2(SCALE_VAL(smem[i], scale), 0, (__global FT*) dst);\n"
"}\n"
"#endif\n"
"}\n"
"}\n"
"__kernel void ifft_multi_radix_rows(__global const uchar* src_ptr, int src_step, int src_offset, int src_rows, int src_cols,\n"
"__global uchar* dst_ptr, int dst_step, int dst_offset, int dst_rows, int dst_cols,\n"
"__global CT* twiddles_ptr, int twiddles_step, int twiddles_offset, const int t, const int nz)\n"
"{\n"
"const int x = get_global_id(0);\n"
"const int y = get_group_id(1);\n"
"const int block_size = LOCAL_SIZE/kercn;\n"
"#ifdef IS_1D\n"
"const FT scale = (FT) 1/dst_cols;\n"
"#else\n"
"const FT scale = (FT) 1/(dst_cols*dst_rows);\n"
"#endif\n"
"__local CT smem[LOCAL_SIZE];\n"
"if (y < nz)\n"
"{\n"
"__global const CT* twiddles = (__global const CT*)(twiddles_ptr + twiddles_offset);\n"
"const int ind = x;\n"
"#if defined(COMPLEX_INPUT) && !defined(NO_CONJUGATE)\n"
"__global const CT* src = (__global const CT*)(src_ptr + mad24(y, src_step, mad24(x, (int)(sizeof(CT)), src_offset)));\n"
"#pragma unroll\n"
"for (int i=0; i<kercn; i++)\n"
"{\n"
"smem[x+i*block_size].x = src[i*block_size].x;\n"
"smem[x+i*block_size].y = -src[i*block_size].y;\n"
"}\n"
"#else\n"
"#if !defined(REAL_INPUT) && defined(NO_CONJUGATE)\n"
"__global const CT* src = (__global const CT*)(src_ptr + mad24(y, src_step, mad24(2, (int)sizeof(FT), src_offset)));\n"
"#pragma unroll\n"
"for (int i=x; i<(LOCAL_SIZE-1)/2; i+=block_size)\n"
"{\n"
"smem[i+1].x = src[i].x;\n"
"smem[i+1].y = -src[i].y;\n"
"smem[LOCAL_SIZE-i-1] = src[i];\n"
"}\n"
"#else\n"
"#pragma unroll\n"
"for (int i=x; i<(LOCAL_SIZE-1)/2; i+=block_size)\n"
"{\n"
"CT src = vload2(0, (__global const FT*)(src_ptr + mad24(y, src_step, mad24(2*i+1, (int)sizeof(FT), src_offset))));\n"
"smem[i+1].x = src.x;\n"
"smem[i+1].y = -src.y;\n"
"smem[LOCAL_SIZE-i-1] = src;\n"
"}\n"
"#endif\n"
"if (x==0)\n"
"{\n"
"smem[0].x = *(__global const FT*)(src_ptr + mad24(y, src_step, src_offset));\n"
"smem[0].y = 0.f;\n"
"if(LOCAL_SIZE % 2 ==0)\n"
"{\n"
"#if !defined(REAL_INPUT) && defined(NO_CONJUGATE)\n"
"smem[LOCAL_SIZE/2].x = src[LOCAL_SIZE/2-1].x;\n"
"#else\n"
"smem[LOCAL_SIZE/2].x = *(__global const FT*)(src_ptr + mad24(y, src_step, mad24(LOCAL_SIZE-1, (int)sizeof(FT), src_offset)));\n"
"#endif\n"
"smem[LOCAL_SIZE/2].y = 0.f;\n"
"}\n"
"}\n"
"#endif\n"
"barrier(CLK_LOCAL_MEM_FENCE);\n"
"RADIX_PROCESS;\n"
"#ifdef COMPLEX_OUTPUT\n"
"__global CT* dst = (__global CT*)(dst_ptr + mad24(y, dst_step, mad24(x, (int)(sizeof(CT)), dst_offset)));\n"
"#pragma unroll\n"
"for (int i=0; i<kercn; i++)\n"
"{\n"
"dst[i*block_size].x = SCALE_VAL(smem[x + i*block_size].x, scale);\n"
"dst[i*block_size].y = SCALE_VAL(-smem[x + i*block_size].y, scale);\n"
"}\n"
"#else\n"
"__global FT* dst = (__global FT*)(dst_ptr + mad24(y, dst_step, mad24(x, (int)(sizeof(FT)), dst_offset)));\n"
"#pragma unroll\n"
"for (int i=0; i<kercn; i++)\n"
"{\n"
"dst[i*block_size] = SCALE_VAL(smem[x + i*block_size].x, scale);\n"
"}\n"
"#endif\n"
"}\n"
"else\n"
"{\n"
"#ifdef COMPLEX_OUTPUT\n"
"__global CT* dst = (__global CT*)(dst_ptr + mad24(y, dst_step, dst_offset));\n"
"#else\n"
"__global FT* dst = (__global FT*)(dst_ptr + mad24(y, dst_step, dst_offset));\n"
"#endif\n"
"#pragma unroll\n"
"for (int i=x; i<dst_cols; i+=block_size)\n"
"dst[i] = 0.f;\n"
"}\n"
"}\n"
"__kernel void ifft_multi_radix_cols(__global const uchar* src_ptr, int src_step, int src_offset, int src_rows, int src_cols,\n"
"__global uchar* dst_ptr, int dst_step, int dst_offset, int dst_rows, int dst_cols,\n"
"__global CT* twiddles_ptr, int twiddles_step, int twiddles_offset, const int t, const int nz)\n"
"{\n"
"const int x = get_group_id(0);\n"
"const int y = get_global_id(1);\n"
"__local CT smem[LOCAL_SIZE];\n"
"if (x < nz)\n"
"{\n"
"#ifdef COMPLEX_INPUT\n"
"__global const uchar* src = src_ptr + mad24(y, src_step, mad24(x, (int)(sizeof(CT)), src_offset));\n"
"__global uchar* dst = dst_ptr + mad24(y, dst_step, mad24(x, (int)(sizeof(CT)), dst_offset));\n"
"__global const CT* twiddles = (__global const CT*)(twiddles_ptr + twiddles_offset);\n"
"const int ind = y;\n"
"const int block_size = LOCAL_SIZE/kercn;\n"
"#pragma unroll\n"
"for (int i=0; i<kercn; i++)\n"
"{\n"
"CT temp = *((__global const CT*)(src + i*block_size*src_step));\n"
"smem[y+i*block_size].x = temp.x;\n"
"smem[y+i*block_size].y = -temp.y;\n"
"}\n"
"barrier(CLK_LOCAL_MEM_FENCE);\n"
"RADIX_PROCESS;\n"
"#pragma unroll\n"
"for (int i=0; i<kercn; i++)\n"
"{\n"
"__global CT* res = (__global CT*)(dst + i*block_size*dst_step);\n"
"res[0].x = smem[y + i*block_size].x;\n"
"res[0].y = -smem[y + i*block_size].y;\n"
"}\n"
"#else\n"
"__global const CT* twiddles = (__global const CT*)(twiddles_ptr + twiddles_offset);\n"
"const int ind = y;\n"
"const int block_size = LOCAL_SIZE/kercn;\n"
"#ifdef EVEN\n"
"if (x!=0 && (x!=(nz-1)))\n"
"#else\n"
"if (x!=0)\n"
"#endif\n"
"{\n"
"__global const uchar* src = src_ptr + mad24(y, src_step, mad24(2*x-1, (int)sizeof(FT), src_offset));\n"
"#pragma unroll\n"
"for (int i=0; i<kercn; i++)\n"
"{\n"
"CT temp = vload2(0, (__global const FT*)(src + i*block_size*src_step));\n"
"smem[y+i*block_size].x = temp.x;\n"
"smem[y+i*block_size].y = -temp.y;\n"
"}\n"
"}\n"
"else\n"
"{\n"
"int ind = x==0 ? 0: 2*x-1;\n"
"__global const FT* src = (__global const FT*)(src_ptr + mad24(1, src_step, mad24(ind, (int)sizeof(FT), src_offset)));\n"
"int step = src_step/(int)sizeof(FT);\n"
"#pragma unroll\n"
"for (int i=y; i<(LOCAL_SIZE-1)/2; i+=block_size)\n"
"{\n"
"smem[i+1].x = src[2*i*step];\n"
"smem[i+1].y = -src[(2*i+1)*step];\n"
"smem[LOCAL_SIZE-i-1].x = src[2*i*step];;\n"
"smem[LOCAL_SIZE-i-1].y = src[(2*i+1)*step];\n"
"}\n"
"if (y==0)\n"
"{\n"
"smem[0].x = *(__global const FT*)(src_ptr + mad24(ind, (int)sizeof(FT), src_offset));\n"
"smem[0].y = 0.f;\n"
"if(LOCAL_SIZE % 2 ==0)\n"
"{\n"
"smem[LOCAL_SIZE/2].x = src[(LOCAL_SIZE-2)*step];\n"
"smem[LOCAL_SIZE/2].y = 0.f;\n"
"}\n"
"}\n"
"}\n"
"barrier(CLK_LOCAL_MEM_FENCE);\n"
"RADIX_PROCESS;\n"
"__global uchar* dst = dst_ptr + mad24(y, dst_step, mad24(x, (int)(sizeof(CT)), dst_offset));\n"
"#pragma unroll\n"
"for (int i=0; i<kercn; i++)\n"
"{\n"
"__global CT* res = (__global CT*)(dst + i*block_size*dst_step);\n"
"res[0].x = smem[y + i*block_size].x;\n"
"res[0].y = -smem[y + i*block_size].y;\n"
"}\n"
"#endif\n"
"}\n"
"}\n"
, "ec5e3eb3327074d6158248324b05ac25", NULL};
struct cv::ocl::internal::ProgramEntry flip_oclsrc={moduleName, "flip",
"#if kercn != 3\n"
"#define loadpix(addr) *(__global const T *)(addr)\n"
"#define storepix(val, addr) *(__global T *)(addr) = val\n"
"#define storepix_2(val0, val1, addr0, addr1) \\\n"
"*(__global T *)(addr0) = val0; *(__global T *)(addr1) = val1\n"
"#define TSIZE (int)sizeof(T)\n"
"#else\n"
"#define loadpix(addr) vload3(0, (__global const T1 *)(addr))\n"
"#define storepix(val, addr) vstore3(val, 0, (__global T1 *)(addr))\n"
"#if DEPTH == 2 || DEPTH == 3\n"
"#define storepix_2(val0, val1, addr0, addr1) \\\n"
"((__global T1 *)(addr0))[0] = val0.x; \\\n"
"((__global T1 *)(addr1))[0] = val1.x; \\\n"
"((__global T1 *)(addr0))[1] = val0.y; \\\n"
"((__global T1 *)(addr1))[1] = val1.y; \\\n"
"((__global T1 *)(addr0))[2] = val0.z; \\\n"
"((__global T1 *)(addr1))[2] = val1.z\n"
"#else\n"
"#define storepix_2(val0, val1, addr0, addr1) \\\n"
"storepix(val0, addr0); \\\n"
"storepix(val1, addr1)\n"
"#endif\n"
"#define TSIZE ((int)sizeof(T1)*3)\n"
"#endif\n"
"__kernel void arithm_flip_rows(__global const uchar * srcptr, int src_step, int src_offset,\n"
"__global uchar * dstptr, int dst_step, int dst_offset,\n"
"int rows, int cols, int thread_rows, int thread_cols)\n"
"{\n"
"int x = get_global_id(0);\n"
"int y0 = get_global_id(1) * PIX_PER_WI_Y;\n"
"if (x < cols)\n"
"{\n"
"int src_index0 = mad24(y0, src_step, mad24(x, TSIZE, src_offset));\n"
"int src_index1 = mad24(rows - y0 - 1, src_step, mad24(x, TSIZE, src_offset));\n"
"int dst_index0 = mad24(y0, dst_step, mad24(x, TSIZE, dst_offset));\n"
"int dst_index1 = mad24(rows - y0 - 1, dst_step, mad24(x, TSIZE, dst_offset));\n"
"#pragma unroll\n"
"for (int y = y0, y1 = min(thread_rows, y0 + PIX_PER_WI_Y); y < y1; ++y)\n"
"{\n"
"T src0 = loadpix(srcptr + src_index0);\n"
"T src1 = loadpix(srcptr + src_index1);\n"
"storepix_2(src1, src0, dstptr + dst_index0, dstptr + dst_index1);\n"
"src_index0 += src_step;\n"
"src_index1 -= src_step;\n"
"dst_index0 += dst_step;\n"
"dst_index1 -= dst_step;\n"
"}\n"
"}\n"
"}\n"
"__kernel void arithm_flip_rows_cols(__global const uchar * srcptr, int src_step, int src_offset,\n"
"__global uchar * dstptr, int dst_step, int dst_offset,\n"
"int rows, int cols, int thread_rows, int thread_cols)\n"
"{\n"
"int x = get_global_id(0);\n"
"int y0 = get_global_id(1)*PIX_PER_WI_Y;\n"
"if (x < cols)\n"
"{\n"
"int src_index0 = mad24(y0, src_step, mad24(x, TSIZE, src_offset));\n"
"int src_index1 = mad24(rows - y0 - 1, src_step, mad24(cols - x - 1, TSIZE, src_offset));\n"
"int dst_index0 = mad24(y0, dst_step, mad24(x, TSIZE, dst_offset));\n"
"int dst_index1 = mad24(rows - y0 - 1, dst_step, mad24(cols - x - 1, TSIZE, dst_offset));\n"
"#pragma unroll\n"
"for (int y = y0, y1 = min(thread_rows, y0 + PIX_PER_WI_Y); y < y1; ++y)\n"
"{\n"
"T src0 = loadpix(srcptr + src_index0);\n"
"T src1 = loadpix(srcptr + src_index1);\n"
"#if kercn == 2\n"
"#if cn == 1\n"
"src0 = src0.s10;\n"
"src1 = src1.s10;\n"
"#endif\n"
"#elif kercn == 4\n"
"#if cn == 1\n"
"src0 = src0.s3210;\n"
"src1 = src1.s3210;\n"
"#elif cn == 2\n"
"src0 = src0.s2301;\n"
"src1 = src1.s2301;\n"
"#endif\n"
"#endif\n"
"storepix_2(src1, src0, dstptr + dst_index0, dstptr + dst_index1);\n"
"src_index0 += src_step;\n"
"src_index1 -= src_step;\n"
"dst_index0 += dst_step;\n"
"dst_index1 -= dst_step;\n"
"}\n"
"}\n"
"}\n"
"__kernel void arithm_flip_cols(__global const uchar * srcptr, int src_step, int src_offset,\n"
"__global uchar * dstptr, int dst_step, int dst_offset,\n"
"int rows, int cols, int thread_rows, int thread_cols)\n"
"{\n"
"int x = get_global_id(0);\n"
"int y0 = get_global_id(1)*PIX_PER_WI_Y;\n"
"if (x < thread_cols)\n"
"{\n"
"int src_index0 = mad24(y0, src_step, mad24(x, TSIZE, src_offset));\n"
"int src_index1 = mad24(y0, src_step, mad24(cols - x - 1, TSIZE, src_offset));\n"
"int dst_index0 = mad24(y0, dst_step, mad24(x, TSIZE, dst_offset));\n"
"int dst_index1 = mad24(y0, dst_step, mad24(cols - x - 1, TSIZE, dst_offset));\n"
"#pragma unroll\n"
"for (int y = y0, y1 = min(rows, y0 + PIX_PER_WI_Y); y < y1; ++y)\n"
"{\n"
"T src0 = loadpix(srcptr + src_index0);\n"
"T src1 = loadpix(srcptr + src_index1);\n"
"#if kercn == 2\n"
"#if cn == 1\n"
"src0 = src0.s10;\n"
"src1 = src1.s10;\n"
"#endif\n"
"#elif kercn == 4\n"
"#if cn == 1\n"
"src0 = src0.s3210;\n"
"src1 = src1.s3210;\n"
"#elif cn == 2\n"
"src0 = src0.s2301;\n"
"src1 = src1.s2301;\n"
"#endif\n"
"#endif\n"
"storepix_2(src1, src0, dstptr + dst_index0, dstptr + dst_index1);\n"
"src_index0 += src_step;\n"
"src_index1 += src_step;\n"
"dst_index0 += dst_step;\n"
"dst_index1 += dst_step;\n"
"}\n"
"}\n"
"}\n"
, "a44c78eaaabc32c2c2ae829f06018921", NULL};
struct cv::ocl::internal::ProgramEntry gemm_oclsrc={moduleName, "gemm",
"#ifdef DOUBLE_SUPPORT\n"
"#ifdef cl_amd_fp64\n"
"#pragma OPENCL EXTENSION cl_amd_fp64:enable\n"
"#elif defined (cl_khr_fp64)\n"
"#pragma OPENCL EXTENSION cl_khr_fp64:enable\n"
"#endif\n"
"#endif\n"
"#define TSIZE (int)sizeof(T)\n"
"#define WTSIZE (int)sizeof(WT)\n"
"#define IND_A mad24(y, A_step, A_offset)\n"
"#define IND_B mad24(x, WTSIZE, B_offset)\n"
"#define STEP_B B_step / WTSIZE\n"
"#define LOCAL_SIZE_ODD (LOCAL_SIZE + 1)\n"
"#if cn==2\n"
"#if kercn==2\n"
"#define MUL(a, b)\\\n"
"{\\\n"
"sum.x += fma(a.x, b.x, - a.y * b.y);\\\n"
"sum.y += fma(a.x, b.y, a.y * b.x);\\\n"
"}\n"
"#else\n"
"#define MUL(a, b)\\\n"
"{\\\n"
"sum.x += fma(a.x, b.x, - a.y * b.y);\\\n"
"sum.y += fma(a.x, b.y, a.y * b.x);\\\n"
"sum.z += fma(a.x, b.z, - a.y * b.w);\\\n"
"sum.w += fma(a.x, b.w, a.y * b.z);\\\n"
"}\n"
"#endif\n"
"#else\n"
"#define MUL(a, b) sum = fma(a, b, sum);\n"
"#endif\n"
"__kernel void gemm(__global const uchar * A_ptr, int A_step, int A_offset,\n"
"__global const uchar * B_ptr, int B_step, int B_offset,\n"
"__global uchar * D_ptr, int D_step, int D_offset, int D_rows, int D_cols,\n"
"int n, T1 alpha, T1 beta)\n"
"{\n"
"int x = get_global_id(0);\n"
"int y = get_global_id(1);\n"
"int lidx = get_local_id(0);\n"
"int lidy = get_local_id(1);\n"
"__global const T* A = (__global const T*)(A_ptr + IND_A);\n"
"__global const WT* B = (__global const WT*)(B_ptr + IND_B);\n"
"WT sum = (WT)(0);\n"
"#if LOCAL_SIZE == 1\n"
"if (x < D_cols && y < D_rows)\n"
"{\n"
"for (int i = 0; i < n; ++i)\n"
"MUL(A[i], B[i*STEP_B]);\n"
"#else\n"
"__local T a_local[LOCAL_SIZE_ODD*LOCAL_SIZE];\n"
"__local WT b_local[LOCAL_SIZE_ODD*LOCAL_SIZE];\n"
"int reps;\n"
"#if NO_MULT\n"
"reps = (n + LOCAL_SIZE-1)/LOCAL_SIZE;\n"
"#else\n"
"reps = n/LOCAL_SIZE;\n"
"#endif\n"
"for (int p = 0; p < reps; ++p)\n"
"{\n"
"if (p * LOCAL_SIZE + lidx < n && y < D_rows)\n"
"a_local[mad24(lidy, LOCAL_SIZE_ODD, lidx)] = A[mad24(p, LOCAL_SIZE, lidx)];\n"
"if (p * LOCAL_SIZE + lidy < n && x < D_cols)\n"
"b_local[mad24(lidy, LOCAL_SIZE_ODD, lidx)] = B[mad24(p, LOCAL_SIZE, lidy)*STEP_B];\n"
"barrier(CLK_LOCAL_MEM_FENCE);\n"
"if (x < D_cols && y < D_rows)\n"
"{\n"
"#if NO_MULT\n"
"int ie = min(LOCAL_SIZE, n - p * LOCAL_SIZE);\n"
"for (int i = 0; i < ie; ++i)\n"
"#else\n"
"for (int i = 0; i < LOCAL_SIZE; ++i)\n"
"#endif\n"
"MUL(a_local[mad24(lidy, LOCAL_SIZE_ODD, i)], b_local[mad24(i, LOCAL_SIZE_ODD, lidx)]);\n"
"}\n"
"barrier(CLK_LOCAL_MEM_FENCE);\n"
"}\n"
"if (x < D_cols && y < D_rows)\n"
"{\n"
"#endif\n"
"__global WT* D = (__global WT*)(D_ptr + mad24(y, D_step, mad24(x, WTSIZE, D_offset)));\n"
"#if HAVE_C\n"
"D[0] = mad(alpha, sum, D[0]*beta);\n"
"#else\n"
"D[0] = alpha * sum;\n"
"#endif\n"
"}\n"
"}\n"
, "0a79f557db56fcdce22ea905e7fc899f", NULL};
struct cv::ocl::internal::ProgramEntry halfconvert_oclsrc={moduleName, "halfconvert",
"#ifdef HALF_SUPPORT\n"
"#ifdef cl_khr_fp16\n"
"#pragma OPENCL EXTENSION cl_khr_fp16:enable\n"
"#endif\n"
"#endif\n"
"__kernel void\n"
"#ifdef FLOAT_TO_HALF\n"
"convertFp16_FP32_to_FP16\n"
"#else\n"
"convertFp16_FP16_to_FP32\n"
"#endif\n"
"(\n"
"__global const uchar * srcptr, int src_step, int src_offset,\n"
"__global uchar * dstptr, int dst_step, int dst_offset,\n"
"int dst_rows, int dst_cols\n"
")\n"
"{\n"
"int x = get_global_id(0);\n"
"int y0 = get_global_id(1) * rowsPerWI;\n"
"if (x < dst_cols)\n"
"{\n"
"int src_index = mad24(y0, src_step, mad24(x, (int)sizeof(srcT), src_offset));\n"
"int dst_index = mad24(y0, dst_step, mad24(x, (int)sizeof(dstT), dst_offset));\n"
"for (int y = y0, y1 = min(dst_rows, y0 + rowsPerWI); y < y1; ++y, src_index += src_step, dst_index += dst_step)\n"
"{\n"
"__global const srcT * src = (__global const srcT *)(srcptr + src_index);\n"
"__global dstT * dst = (__global dstT *)(dstptr + dst_index);\n"
"#ifdef FLOAT_TO_HALF\n"
"vstore_half(src[0], 0, dst);\n"
"#else\n"
"dst[0] = vload_half(0, src);\n"
"#endif\n"
"}\n"
"}\n"
"}\n"
, "c2eaf2b0bc47a33439462e868ca03a78", NULL};
struct cv::ocl::internal::ProgramEntry inrange_oclsrc={moduleName, "inrange",
"#ifdef DOUBLE_SUPPORT\n"
"#ifdef cl_amd_fp64\n"
"#pragma OPENCL EXTENSION cl_amd_fp64:enable\n"
"#elif defined (cl_khr_fp64)\n"
"#pragma OPENCL EXTENSION cl_khr_fp64:enable\n"
"#endif\n"
"#endif\n"
"__kernel void inrange(__global const uchar * src1ptr, int src1_step, int src1_offset,\n"
"__global uchar * dstptr, int dst_step, int dst_offset, int dst_rows, int dst_cols,\n"
"#ifdef HAVE_SCALAR\n"
"__global const srcT1 * src2, __global const srcT1 * src3,\n"
"#else\n"
"__global const uchar * src2ptr, int src2_step, int src2_offset,\n"
"__global const uchar * src3ptr, int src3_step, int src3_offset,\n"
"#endif\n"
"int rowsPerWI)\n"
"{\n"
"int x = get_global_id(0);\n"
"int y0 = get_global_id(1) * rowsPerWI;\n"
"if (x < dst_cols)\n"
"{\n"
"int src1_index = mad24(y0, src1_step, mad24(x, (int)sizeof(srcT1) * kercn, src1_offset));\n"
"int dst_index = mad24(y0, dst_step, mad24(x, colsPerWI, dst_offset));\n"
"#ifndef HAVE_SCALAR\n"
"int src2_index = mad24(y0, src2_step, mad24(x, (int)sizeof(srcT1) * kercn, src2_offset));\n"
"int src3_index = mad24(y0, src3_step, mad24(x, (int)sizeof(srcT1) * kercn, src3_offset));\n"
"#endif\n"
"for (int y = y0, y1 = min(dst_rows, y0 + rowsPerWI); y < y1; ++y, src1_index += src1_step, dst_index += dst_step)\n"
"{\n"
"#if kercn >= cn && kercn == 4 && depth <= 4 && !defined HAVE_SCALAR\n"
"srcT src1 = *(__global const srcT *)(src1ptr + src1_index);\n"
"srcT src2 = *(__global const srcT *)(src2ptr + src2_index);\n"
"srcT src3 = *(__global const srcT *)(src3ptr + src3_index);\n"
"__global dstT * dst = (__global dstT *)(dstptr + dst_index);\n"
"#if cn == 1\n"
"dst[0] = src2 > src1 || src3 < src1 ? (dstT)(0) : (dstT)(255);\n"
"#elif cn == 2\n"
"dst[0] = (dstT)(src2.xy > src1.xy || src3.xy < src1.xy ||\n"
"src2.zw > src1.zw || src3.zw < src1.zw ? (dstT)(0) : (dstT)(255);\n"
"#elif cn == 4\n"
"dst[0] = (dstT)(src2.x > src1.x || src3.x < src1.x ||\n"
"src2.y > src1.y || src3.y < src1.y ||\n"
"src2.z > src1.z || src3.z < src1.z ||\n"
"src2.w > src1.w || src3.w < src1.w ? 0 : 255);\n"
"#endif\n"
"#else\n"
"__global const srcT1 * src1 = (__global const srcT1 *)(src1ptr + src1_index);\n"
"__global uchar * dst = dstptr + dst_index;\n"
"#ifndef HAVE_SCALAR\n"
"__global const srcT1 * src2 = (__global const srcT1 *)(src2ptr + src2_index);\n"
"__global const srcT1 * src3 = (__global const srcT1 *)(src3ptr + src3_index);\n"
"#endif\n"
"#pragma unroll\n"
"for (int px = 0; px < colsPerWI; ++px, src1 += cn\n"
"#ifndef HAVE_SCALAR\n"
", src2 += cn, src3 += cn\n"
"#endif\n"
")\n"
"{\n"
"dst[px] = 255;\n"
"for (int c = 0; c < cn; ++c)\n"
"if (src2[c] > src1[c] || src3[c] < src1[c])\n"
"{\n"
"dst[px] = 0;\n"
"break;\n"
"}\n"
"}\n"
"#endif\n"
"#ifndef HAVE_SCALAR\n"
"src2_index += src2_step;\n"
"src3_index += src3_step;\n"
"#endif\n"
"}\n"
"}\n"
"}\n"
, "e7220f9dc5b30fc5558622a452890287", NULL};
struct cv::ocl::internal::ProgramEntry intel_gemm_oclsrc={moduleName, "intel_gemm",
"#if defined(cl_intel_subgroups)\n"
"#pragma OPENCL EXTENSION cl_intel_subgroups : enable\n"
"#endif\n"
"#if defined(cl_intel_subgroups)\n"
"#define VEC_SIZE 4\n"
"#define LWG_HEIGHT 4\n"
"#define TILE_M 8\n"
"#define TILE_K 16\n"
"#define TILE_N 32\n"
"__attribute__((reqd_work_group_size(8, LWG_HEIGHT, 1)))\n"
"__kernel void intelblas_gemm_buffer_NN_sp(\n"
"const __global float *src0, int off0,\n"
"const __global float *src1, int off1,\n"
"__global float *dst, int offd,\n"
"int M,\n"
"int N,\n"
"int K,\n"
"float alpha,\n"
"float beta,\n"
"int ldA,\n"
"int ldB,\n"
"int ldC,\n"
"int start_index,\n"
"int stride)\n"
"{\n"
"const int group_x = get_group_id(0);\n"
"const int group_y = get_group_id(1);\n"
"const int local_x = get_local_id(0);\n"
"const int local_y = get_local_id(1);\n"
"const int global_x = get_global_id(0);\n"
"const int global_y = get_global_id(1);\n"
"float4 brow;\n"
"float2 arow0, arow1, arow2, arow3, arow4, arow5, arow6, arow7;\n"
"__global float *dst_write0 = dst + local_x * VEC_SIZE + ( group_x * TILE_N ) + ( group_y * LWG_HEIGHT * TILE_M + local_y * TILE_M) * ldC + offd;\n"
"const __global float *src0_read = src0 + local_x * ( TILE_K / 8 ) + ( group_y * LWG_HEIGHT * TILE_M + local_y * TILE_M ) * ldA + start_index + off0;\n"
"const __global float *src1_read0 = src1 + local_x * VEC_SIZE + ( group_x * TILE_N ) + start_index * ldB + off1;\n"
"float4 dot00 = (start_index != 0) ? vload4(0, dst_write0) : ((beta != 0.0) ? ((float)beta * vload4(0, dst_write0 )) : (float4)(0.0));\n"
"float4 dot01 = (start_index != 0) ? vload4(0, dst_write0 + 1 * ldC) : ((beta != 0.0) ? ((float)beta * vload4(0, dst_write0 + 1 * ldC)) : (float4)(0.0));\n"
"float4 dot02 = (start_index != 0) ? vload4(0, dst_write0 + 2 * ldC) : ((beta != 0.0) ? ((float)beta * vload4(0, dst_write0 + 2 * ldC)) : (float4)(0.0));\n"
"float4 dot03 = (start_index != 0) ? vload4(0, dst_write0 + 3 * ldC) : ((beta != 0.0) ? ((float)beta * vload4(0, dst_write0 + 3 * ldC)) : (float4)(0.0));\n"
"float4 dot04 = (start_index != 0) ? vload4(0, dst_write0 + 4 * ldC) : ((beta != 0.0) ? ((float)beta * vload4(0, dst_write0 + 4 * ldC)) : (float4)(0.0));\n"
"float4 dot05 = (start_index != 0) ? vload4(0, dst_write0 + 5 * ldC) : ((beta != 0.0) ? ((float)beta * vload4(0, dst_write0 + 5 * ldC)) : (float4)(0.0));\n"
"float4 dot06 = (start_index != 0) ? vload4(0, dst_write0 + 6 * ldC) : ((beta != 0.0) ? ((float)beta * vload4(0, dst_write0 + 6 * ldC)) : (float4)(0.0));\n"
"float4 dot07 = (start_index != 0) ? vload4(0, dst_write0 + 7 * ldC) : ((beta != 0.0) ? ((float)beta * vload4(0, dst_write0 + 7 * ldC)) : (float4)(0.0));\n"
"int end_index = min(start_index + stride, K);\n"
"int w = start_index;\n"
"while( w + TILE_K <= end_index ) {\n"
"arow0 = (float)alpha * vload2(0, src0_read + 0 * ldA);\n"
"arow1 = (float)alpha * vload2(0, src0_read + 1 * ldA);\n"
"arow2 = (float)alpha * vload2(0, src0_read + 2 * ldA);\n"
"arow3 = (float)alpha * vload2(0, src0_read + 3 * ldA);\n"
"arow4 = (float)alpha * vload2(0, src0_read + 4 * ldA);\n"
"arow5 = (float)alpha * vload2(0, src0_read + 5 * ldA);\n"
"arow6 = (float)alpha * vload2(0, src0_read + 6 * ldA);\n"
"arow7 = (float)alpha * vload2(0, src0_read + 7 * ldA);\n"
"#define MM_DOT_PRODUCT(index, suffix) \\\n"
"brow = vload4(0, src1_read0); src1_read0 += ldB; \\\n"
"dot00 = mad((float4)(intel_sub_group_shuffle(arow0.s##suffix,index)),brow,dot00); \\\n"
"dot01 = mad((float4)(intel_sub_group_shuffle(arow1.s##suffix,index)),brow,dot01); \\\n"
"dot02 = mad((float4)(intel_sub_group_shuffle(arow2.s##suffix,index)),brow,dot02); \\\n"
"dot03 = mad((float4)(intel_sub_group_shuffle(arow3.s##suffix,index)),brow,dot03); \\\n"
"dot04 = mad((float4)(intel_sub_group_shuffle(arow4.s##suffix,index)),brow,dot04); \\\n"
"dot05 = mad((float4)(intel_sub_group_shuffle(arow5.s##suffix,index)),brow,dot05); \\\n"
"dot06 = mad((float4)(intel_sub_group_shuffle(arow6.s##suffix,index)),brow,dot06); \\\n"
"dot07 = mad((float4)(intel_sub_group_shuffle(arow7.s##suffix,index)),brow,dot07);\n"
"MM_DOT_PRODUCT(0,0);\n"
"MM_DOT_PRODUCT(0,1);\n"
"MM_DOT_PRODUCT(1,0);\n"
"MM_DOT_PRODUCT(1,1);\n"
"MM_DOT_PRODUCT(2,0);\n"
"MM_DOT_PRODUCT(2,1);\n"
"MM_DOT_PRODUCT(3,0);\n"
"MM_DOT_PRODUCT(3,1);\n"
"MM_DOT_PRODUCT(4,0);\n"
"MM_DOT_PRODUCT(4,1);\n"
"MM_DOT_PRODUCT(5,0);\n"
"MM_DOT_PRODUCT(5,1);\n"
"MM_DOT_PRODUCT(6,0);\n"
"MM_DOT_PRODUCT(6,1);\n"
"MM_DOT_PRODUCT(7,0);\n"
"MM_DOT_PRODUCT(7,1);\n"
"#undef MM_DOT_PRODUCT\n"
"src0_read += TILE_K;\n"
"w += TILE_K;\n"
"}\n"
"vstore4(dot00, 0, dst_write0); dst_write0 += ldC;\n"
"vstore4(dot01, 0, dst_write0); dst_write0 += ldC;\n"
"vstore4(dot02, 0, dst_write0); dst_write0 += ldC;\n"
"vstore4(dot03, 0, dst_write0); dst_write0 += ldC;\n"
"vstore4(dot04, 0, dst_write0); dst_write0 += ldC;\n"
"vstore4(dot05, 0, dst_write0); dst_write0 += ldC;\n"
"vstore4(dot06, 0, dst_write0); dst_write0 += ldC;\n"
"vstore4(dot07, 0, dst_write0); dst_write0 += ldC;\n"
"}\n"
"#undef VEC_SIZE\n"
"#undef LWG_HEIGHT\n"
"#undef TILE_M\n"
"#undef TILE_K\n"
"#undef TILE_N\n"
"#define VEC_SIZE 4\n"
"#define LWG_HEIGHT 4\n"
"#define TILE_M 8\n"
"#define TILE_K 16\n"
"#define TILE_N 32\n"
"__attribute__((reqd_work_group_size(8, LWG_HEIGHT, 1)))\n"
"__kernel void intelblas_gemm_buffer_NN(\n"
"const __global float *src0, int off0,\n"
"const __global float *src1, int off1,\n"
"__global float *dst, int offd,\n"
"int M,\n"
"int N,\n"
"int K,\n"
"float alpha,\n"
"float beta,\n"
"int ldA,\n"
"int ldB,\n"
"int ldC,\n"
"int start_index,\n"
"int stride)\n"
"{\n"
"const int group_x = get_group_id(0);\n"
"const int group_y = get_group_id(1);\n"
"const int local_x = get_local_id(0);\n"
"const int local_y = get_local_id(1);\n"
"const int global_x = get_global_id(0);\n"
"const int global_y = get_global_id(1);\n"
"float4 brow;\n"
"float2 arow0, arow1, arow2, arow3, arow4, arow5, arow6, arow7;\n"
"__global float *dst_write0 = dst + local_x * VEC_SIZE + ( group_x * TILE_N ) + ( group_y * LWG_HEIGHT * TILE_M + local_y * TILE_M) * ldC + offd;\n"
"const __global float *src0_read = src0 + local_x * ( TILE_K / 8 ) + ( group_y * LWG_HEIGHT * TILE_M + local_y * TILE_M ) * ldA + start_index + off0;\n"
"const __global float *src1_read0 = src1 + local_x * VEC_SIZE + ( group_x * TILE_N ) + start_index * ldB + off1;\n"
"int border = -(group_y * LWG_HEIGHT * TILE_M + local_y * TILE_M);\n"
"int row0 = mad24(global_y, TILE_M, 0) < M ? 0 : border;\n"
"int row1 = mad24(global_y, TILE_M, 1) < M ? 1 : border;\n"
"int row2 = mad24(global_y, TILE_M, 2) < M ? 2 : border;\n"
"int row3 = mad24(global_y, TILE_M, 3) < M ? 3 : border;\n"
"int row4 = mad24(global_y, TILE_M, 4) < M ? 4 : border;\n"
"int row5 = mad24(global_y, TILE_M, 5) < M ? 5 : border;\n"
"int row6 = mad24(global_y, TILE_M, 6) < M ? 6 : border;\n"
"int row7 = mad24(global_y, TILE_M, 7) < M ? 7 : border;\n"
"float4 dot00 = (start_index != 0) ? vload4(0, dst_write0) : ((beta != 0.0) ? ((float)beta * vload4(0, dst_write0 )) : (float4)(0.0));\n"
"float4 dot01 = (start_index != 0) ? vload4(0, dst_write0 + 1 * ldC) : ((beta != 0.0) ? ((float)beta * vload4(0, dst_write0 + 1 * ldC)) : (float4)(0.0));\n"
"float4 dot02 = (start_index != 0) ? vload4(0, dst_write0 + 2 * ldC) : ((beta != 0.0) ? ((float)beta * vload4(0, dst_write0 + 2 * ldC)) : (float4)(0.0));\n"
"float4 dot03 = (start_index != 0) ? vload4(0, dst_write0 + 3 * ldC) : ((beta != 0.0) ? ((float)beta * vload4(0, dst_write0 + 3 * ldC)) : (float4)(0.0));\n"
"float4 dot04 = (start_index != 0) ? vload4(0, dst_write0 + 4 * ldC) : ((beta != 0.0) ? ((float)beta * vload4(0, dst_write0 + 4 * ldC)) : (float4)(0.0));\n"
"float4 dot05 = (start_index != 0) ? vload4(0, dst_write0 + 5 * ldC) : ((beta != 0.0) ? ((float)beta * vload4(0, dst_write0 + 5 * ldC)) : (float4)(0.0));\n"
"float4 dot06 = (start_index != 0) ? vload4(0, dst_write0 + 6 * ldC) : ((beta != 0.0) ? ((float)beta * vload4(0, dst_write0 + 6 * ldC)) : (float4)(0.0));\n"
"float4 dot07 = (start_index != 0) ? vload4(0, dst_write0 + 7 * ldC) : ((beta != 0.0) ? ((float)beta * vload4(0, dst_write0 + 7 * ldC)) : (float4)(0.0));\n"
"int end_index = min(start_index + stride, K);\n"
"int w = start_index;\n"
"while( w + TILE_K <= end_index ) {\n"
"arow0 = (float)alpha * vload2(0, src0_read + row0 * ldA);\n"
"arow1 = (float)alpha * vload2(0, src0_read + row1 * ldA);\n"
"arow2 = (float)alpha * vload2(0, src0_read + row2 * ldA);\n"
"arow3 = (float)alpha * vload2(0, src0_read + row3 * ldA);\n"
"arow4 = (float)alpha * vload2(0, src0_read + row4 * ldA);\n"
"arow5 = (float)alpha * vload2(0, src0_read + row5 * ldA);\n"
"arow6 = (float)alpha * vload2(0, src0_read + row6 * ldA);\n"
"arow7 = (float)alpha * vload2(0, src0_read + row7 * ldA);\n"
"#define MM_DOT_PRODUCT(index,suffix) \\\n"
"brow = vload4(0, src1_read0); src1_read0 += ldB; \\\n"
"dot00 = mad((float4)(intel_sub_group_shuffle(arow0.s##suffix,index)),brow,dot00); \\\n"
"dot01 = mad((float4)(intel_sub_group_shuffle(arow1.s##suffix,index)),brow,dot01); \\\n"
"dot02 = mad((float4)(intel_sub_group_shuffle(arow2.s##suffix,index)),brow,dot02); \\\n"
"dot03 = mad((float4)(intel_sub_group_shuffle(arow3.s##suffix,index)),brow,dot03); \\\n"
"dot04 = mad((float4)(intel_sub_group_shuffle(arow4.s##suffix,index)),brow,dot04); \\\n"
"dot05 = mad((float4)(intel_sub_group_shuffle(arow5.s##suffix,index)),brow,dot05); \\\n"
"dot06 = mad((float4)(intel_sub_group_shuffle(arow6.s##suffix,index)),brow,dot06); \\\n"
"dot07 = mad((float4)(intel_sub_group_shuffle(arow7.s##suffix,index)),brow,dot07);\n"
"MM_DOT_PRODUCT(0,0);\n"
"MM_DOT_PRODUCT(0,1);\n"
"MM_DOT_PRODUCT(1,0);\n"
"MM_DOT_PRODUCT(1,1);\n"
"MM_DOT_PRODUCT(2,0);\n"
"MM_DOT_PRODUCT(2,1);\n"
"MM_DOT_PRODUCT(3,0);\n"
"MM_DOT_PRODUCT(3,1);\n"
"MM_DOT_PRODUCT(4,0);\n"
"MM_DOT_PRODUCT(4,1);\n"
"MM_DOT_PRODUCT(5,0);\n"
"MM_DOT_PRODUCT(5,1);\n"
"MM_DOT_PRODUCT(6,0);\n"
"MM_DOT_PRODUCT(6,1);\n"
"MM_DOT_PRODUCT(7,0);\n"
"MM_DOT_PRODUCT(7,1);\n"
"#undef MM_DOT_PRODUCT\n"
"src0_read += TILE_K;\n"
"w += TILE_K;\n"
"}\n"
"if(w < end_index) {\n"
"arow0.x = ((w + local_x * 2) < K) ? (float)alpha * (src0_read + row0 * ldA)[0] : 0.0f;\n"
"arow0.y = ((w + local_x * 2 + 1) < K) ? (float)alpha * (src0_read + row0 * ldA)[1] : 0.0f;\n"
"arow1.x = ((w + local_x * 2) < K) ? (float)alpha * (src0_read + row1 * ldA)[0] : 0.0f;\n"
"arow1.y = ((w + local_x * 2 + 1) < K) ? (float)alpha * (src0_read + row1 * ldA)[1] : 0.0f;\n"
"arow2.x = ((w + local_x * 2) < K) ? (float)alpha * (src0_read + row2 * ldA)[0] : 0.0f;\n"
"arow2.y = ((w + local_x * 2 + 1) < K) ? (float)alpha * (src0_read + row2 * ldA)[1] : 0.0f;\n"
"arow3.x = ((w + local_x * 2) < K) ? (float)alpha * (src0_read + row3 * ldA)[0] : 0.0f;\n"
"arow3.y = ((w + local_x * 2 + 1) < K) ? (float)alpha * (src0_read + row3 * ldA)[1] : 0.0f;\n"
"arow4.x = ((w + local_x * 2) < K) ? (float)alpha * (src0_read + row4 * ldA)[0] : 0.0f;\n"
"arow4.y = ((w + local_x * 2 + 1) < K) ? (float)alpha * (src0_read + row4 * ldA)[1] : 0.0f;\n"
"arow5.x = ((w + local_x * 2) < K) ? (float)alpha * (src0_read + row5 * ldA)[0] : 0.0f;\n"
"arow5.y = ((w + local_x * 2 + 1) < K) ? (float)alpha * (src0_read + row5 * ldA)[1] : 0.0f;\n"
"arow6.x = ((w + local_x * 2) < K) ? (float)alpha * (src0_read + row6 * ldA)[0] : 0.0f;\n"
"arow6.y = ((w + local_x * 2 + 1) < K) ? (float)alpha * (src0_read + row6 * ldA)[1] : 0.0f;\n"
"arow7.x = ((w + local_x * 2) < K) ? (float)alpha * (src0_read + row7 * ldA)[0] : 0.0f;\n"
"arow7.y = ((w + local_x * 2 + 1) < K) ? (float)alpha * (src0_read + row7 * ldA)[1] : 0.0f;\n"
"#define MM_DOT_PRODUCT(index,suffix) \\\n"
"brow = (w < K) ? vload4(0, src1_read0) : (float)0.0f; src1_read0 += ldB; w++; \\\n"
"dot00 = mad((float4)(intel_sub_group_shuffle( arow0.s##suffix, index )),brow,dot00 ); \\\n"
"dot01 = mad((float4)(intel_sub_group_shuffle( arow1.s##suffix, index )),brow,dot01 ); \\\n"
"dot02 = mad((float4)(intel_sub_group_shuffle( arow2.s##suffix, index )),brow,dot02 ); \\\n"
"dot03 = mad((float4)(intel_sub_group_shuffle( arow3.s##suffix, index )),brow,dot03 ); \\\n"
"dot04 = mad((float4)(intel_sub_group_shuffle( arow4.s##suffix, index )),brow,dot04 ); \\\n"
"dot05 = mad((float4)(intel_sub_group_shuffle( arow5.s##suffix, index )),brow,dot05 ); \\\n"
"dot06 = mad((float4)(intel_sub_group_shuffle( arow6.s##suffix, index )),brow,dot06 ); \\\n"
"dot07 = mad((float4)(intel_sub_group_shuffle( arow7.s##suffix, index )),brow,dot07 );\n"
"MM_DOT_PRODUCT(0,0);\n"
"MM_DOT_PRODUCT(0,1);\n"
"MM_DOT_PRODUCT(1,0);\n"
"MM_DOT_PRODUCT(1,1);\n"
"MM_DOT_PRODUCT(2,0);\n"
"MM_DOT_PRODUCT(2,1);\n"
"MM_DOT_PRODUCT(3,0);\n"
"MM_DOT_PRODUCT(3,1);\n"
"MM_DOT_PRODUCT(4,0);\n"
"MM_DOT_PRODUCT(4,1);\n"
"MM_DOT_PRODUCT(5,0);\n"
"MM_DOT_PRODUCT(5,1);\n"
"MM_DOT_PRODUCT(6,0);\n"
"MM_DOT_PRODUCT(6,1);\n"
"MM_DOT_PRODUCT(7,0);\n"
"MM_DOT_PRODUCT(7,1);\n"
"#undef MM_DOT_PRODUCT\n"
"}\n"
"if(global_x * 4 < N && global_y * 8 < M) {\n"
"if(mad24(global_x, 4, 3) < N) {\n"
"vstore4(dot00, 0, dst_write0); dst_write0 += ldC;\n"
"if(mad24(global_y, 8, 1) < M) { vstore4(dot01, 0, dst_write0); dst_write0 += ldC; }\n"
"else return;\n"
"if(mad24(global_y, 8, 2) < M) { vstore4(dot02, 0, dst_write0); dst_write0 += ldC; }\n"
"else return;\n"
"if(mad24(global_y, 8, 3) < M) { vstore4(dot03, 0, dst_write0); dst_write0 += ldC; }\n"
"else return;\n"
"if(mad24(global_y, 8, 4) < M) { vstore4(dot04, 0, dst_write0); dst_write0 += ldC; }\n"
"else return;\n"
"if(mad24(global_y, 8, 5) < M) { vstore4(dot05, 0, dst_write0); dst_write0 += ldC; }\n"
"else return;\n"
"if(mad24(global_y, 8, 6) < M) { vstore4(dot06, 0, dst_write0); dst_write0 += ldC; }\n"
"else return;\n"
"if(mad24(global_y, 8, 7) < M) { vstore4(dot07, 0, dst_write0); }\n"
"} else if(mad24(global_x, 4, 2) < N) {\n"
"vstore2(dot00.xy, 0, dst_write0);\n"
"dst_write0[2] = dot00.z;\n"
"dst_write0 += ldC;\n"
"if(mad24(global_y, 8, 1) < M) {\n"
"vstore2(dot01.xy, 0, dst_write0);\n"
"dst_write0[2] = dot01.z;\n"
"dst_write0 += ldC;\n"
"} else\n"
"return;\n"
"if(mad24(global_y, 8, 2) < M) {\n"
"vstore2(dot02.xy, 0, dst_write0);\n"
"dst_write0[2] = dot02.z;\n"
"dst_write0 += ldC;\n"
"} else\n"
"return;\n"
"if(mad24(global_y, 8, 3) < M) {\n"
"vstore2(dot03.xy, 0, dst_write0);\n"
"dst_write0[2] = dot03.z;\n"
"dst_write0 += ldC;\n"
"} else\n"
"return;\n"
"if(mad24(global_y, 8, 4) < M) {\n"
"vstore2(dot04.xy, 0, dst_write0);\n"
"dst_write0[2] = dot04.z;\n"
"dst_write0 += ldC;\n"
"} else\n"
"return;\n"
"if(mad24(global_y, 8, 5) < M) {\n"
"vstore2(dot05.xy, 0, dst_write0);\n"
"dst_write0[2] = dot05.z;\n"
"dst_write0 += ldC;\n"
"} else\n"
"return;\n"
"if(mad24(global_y, 8, 6) < M) {\n"
"vstore2(dot06.xy, 0, dst_write0);\n"
"dst_write0[2] = dot06.z;\n"
"dst_write0 += ldC;\n"
"} else\n"
"return;\n"
"if(mad24(global_y, 8, 7) < M) {\n"
"vstore2(dot07.xy, 0, dst_write0);\n"
"dst_write0[2] = dot07.z;\n"
"}\n"
"} else if(mad24(global_x, 4, 1) < N) {\n"
"vstore2(dot00.xy, 0, dst_write0); dst_write0 += ldC;\n"
"if(mad24(global_y, 8, 1) < M) { vstore2(dot01.xy, 0, dst_write0); dst_write0 += ldC; }\n"
"else return;\n"
"if(mad24(global_y, 8, 2) < M) { vstore2(dot02.xy, 0, dst_write0); dst_write0 += ldC; }\n"
"else return;\n"
"if(mad24(global_y, 8, 3) < M) { vstore2(dot03.xy, 0, dst_write0); dst_write0 += ldC; }\n"
"else return;\n"
"if(mad24(global_y, 8, 4) < M) { vstore2(dot04.xy, 0, dst_write0); dst_write0 += ldC; }\n"
"else return;\n"
"if(mad24(global_y, 8, 5) < M) { vstore2(dot05.xy, 0, dst_write0); dst_write0 += ldC; }\n"
"else return;\n"
"if(mad24(global_y, 8, 6) < M) { vstore2(dot06.xy, 0, dst_write0); dst_write0 += ldC; }\n"
"else return;\n"
"if(mad24(global_y, 8, 7) < M) { vstore2(dot07.xy, 0, dst_write0); }\n"
"} else {\n"
"dst_write0[0] = dot00.x; dst_write0 += ldC;\n"
"if(mad24(global_y, 8, 1) < M) { dst_write0[0] = dot01.x; dst_write0 += ldC; }\n"
"else return;\n"
"if(mad24(global_y, 8, 2) < M) { dst_write0[0] = dot02.x; dst_write0 += ldC; }\n"
"else return;\n"
"if(mad24(global_y, 8, 3) < M) { dst_write0[0] = dot03.x; dst_write0 += ldC; }\n"
"else return;\n"
"if(mad24(global_y, 8, 4) < M) { dst_write0[0] = dot04.x; dst_write0 += ldC; }\n"
"else return;\n"
"if(mad24(global_y, 8, 5) < M) { dst_write0[0] = dot05.x; dst_write0 += ldC; }\n"
"else return;\n"
"if(mad24(global_y, 8, 6) < M) { dst_write0[0] = dot06.x; dst_write0 += ldC; }\n"
"else return;\n"
"if(mad24(global_y, 8, 7) < M) { dst_write0[0] = dot07.x; }\n"
"}\n"
"}\n"
"}\n"
"#undef VEC_SIZE\n"
"#undef LWG_HEIGHT\n"
"#undef TILE_M\n"
"#undef TILE_K\n"
"#undef TILE_N\n"
"#define VEC_SIZE 1\n"
"#define LWG_HEIGHT 16\n"
"#define TILE_M 8\n"
"#define TILE_K 32\n"
"#define TILE_N 8\n"
"#define SLM_BLOCK 512\n"
"__attribute__((reqd_work_group_size(8, LWG_HEIGHT, 1)))\n"
"__kernel void intelblas_gemm_buffer_NT(\n"
"const __global float *src0, int off0,\n"
"const __global float *src1, int off1,\n"
"__global float *dst, int offd,\n"
"int M,\n"
"int N,\n"
"int K,\n"
"float alpha,\n"
"float beta,\n"
"int ldA,\n"
"int ldB,\n"
"int ldC)\n"
"{\n"
"const int group_x = get_group_id(0);\n"
"const int group_y = get_group_id(1);\n"
"const int local_x = get_local_id(0);\n"
"const int local_y = get_local_id(1);\n"
"const int global_x = get_global_id(0);\n"
"const int global_y = get_global_id(1);\n"
"float8 dot00 = 0.f;\n"
"float8 dot01 = 0.f;\n"
"float8 dot02 = 0.f;\n"
"float8 dot03 = 0.f;\n"
"float8 dot04 = 0.f;\n"
"float8 dot05 = 0.f;\n"
"float8 dot06 = 0.f;\n"
"float8 dot07 = 0.f;\n"
"float4 brow0;\n"
"float4 brow1;\n"
"float4 brow2;\n"
"float4 brow3;\n"
"float4 brow4;\n"
"float4 brow5;\n"
"float4 brow6;\n"
"float4 brow7;\n"
"__global float *dst_write0 = dst + local_x * VEC_SIZE + ( group_x * TILE_N ) + ( group_y * LWG_HEIGHT * TILE_M + local_y * TILE_M) * ldC + offd;\n"
"const __global float *src0_read = src0 + local_x * ( TILE_K / 8 ) + ( group_y * LWG_HEIGHT * TILE_M + local_y * TILE_M ) * ldA + off0;\n"
"const __global float *src1_read0 = src1 + ( group_x * TILE_N ) * ldB + off1;\n"
"__local float slm_brow[8 * SLM_BLOCK];\n"
"__local float* slm_brow0;\n"
"int local_index = mad24(local_y, 8, local_x) * 4;\n"
"int w;\n"
"for(int b_tile = 0; b_tile < K; b_tile += SLM_BLOCK) {\n"
"barrier(CLK_LOCAL_MEM_FENCE);\n"
"vstore4(vload4(0, src1_read0 + mad24(0, ldB, local_index)), 0, slm_brow + mad24(0, SLM_BLOCK, local_index));\n"
"vstore4(vload4(0, src1_read0 + mad24(1, ldB, local_index)), 0, slm_brow + mad24(1, SLM_BLOCK, local_index));\n"
"vstore4(vload4(0, src1_read0 + mad24(2, ldB, local_index)), 0, slm_brow + mad24(2, SLM_BLOCK, local_index));\n"
"vstore4(vload4(0, src1_read0 + mad24(3, ldB, local_index)), 0, slm_brow + mad24(3, SLM_BLOCK, local_index));\n"
"vstore4(vload4(0, src1_read0 + mad24(4, ldB, local_index)), 0, slm_brow + mad24(4, SLM_BLOCK, local_index));\n"
"vstore4(vload4(0, src1_read0 + mad24(5, ldB, local_index)), 0, slm_brow + mad24(5, SLM_BLOCK, local_index));\n"
"vstore4(vload4(0, src1_read0 + mad24(6, ldB, local_index)), 0, slm_brow + mad24(6, SLM_BLOCK, local_index));\n"
"vstore4(vload4(0, src1_read0 + mad24(7, ldB, local_index)), 0, slm_brow + mad24(7, SLM_BLOCK, local_index));\n"
"barrier(CLK_LOCAL_MEM_FENCE);\n"
"slm_brow0 = slm_brow + local_x * (TILE_K / 8);\n"
"w = b_tile;\n"
"int end_w = min(b_tile + SLM_BLOCK, K);\n"
"while( w + TILE_K <= end_w ) {\n"
"float4 arow;\n"
"brow0 = vload4(0, slm_brow0 + 0 * SLM_BLOCK);\n"
"brow1 = vload4(0, slm_brow0 + 1 * SLM_BLOCK);\n"
"brow2 = vload4(0, slm_brow0 + 2 * SLM_BLOCK);\n"
"brow3 = vload4(0, slm_brow0 + 3 * SLM_BLOCK);\n"
"brow4 = vload4(0, slm_brow0 + 4 * SLM_BLOCK);\n"
"brow5 = vload4(0, slm_brow0 + 5 * SLM_BLOCK);\n"
"brow6 = vload4(0, slm_brow0 + 6 * SLM_BLOCK);\n"
"brow7 = vload4(0, slm_brow0 + 7 * SLM_BLOCK);\n"
"#define MM_DOT_PRODUCT(_row,_dot) \\\n"
"arow = vload4(0, src0_read + _row * ldA); \\\n"
"_dot = mad( (float8)(arow.x), (float8)(brow0.x, brow1.x, brow2.x, brow3.x, brow4.x, brow5.x, brow6.x, brow7.x), _dot ); \\\n"
"_dot = mad( (float8)(arow.y), (float8)(brow0.y, brow1.y, brow2.y, brow3.y, brow4.y, brow5.y, brow6.y, brow7.y), _dot ); \\\n"
"_dot = mad( (float8)(arow.z), (float8)(brow0.z, brow1.z, brow2.z, brow3.z, brow4.z, brow5.z, brow6.z, brow7.z), _dot ); \\\n"
"_dot = mad( (float8)(arow.w), (float8)(brow0.w, brow1.w, brow2.w, brow3.w, brow4.w, brow5.w, brow6.w, brow7.w), _dot );\n"
"MM_DOT_PRODUCT(0,dot00);\n"
"MM_DOT_PRODUCT(1,dot01);\n"
"MM_DOT_PRODUCT(2,dot02);\n"
"MM_DOT_PRODUCT(3,dot03);\n"
"MM_DOT_PRODUCT(4,dot04);\n"
"MM_DOT_PRODUCT(5,dot05);\n"
"MM_DOT_PRODUCT(6,dot06);\n"
"MM_DOT_PRODUCT(7,dot07);\n"
"#undef MM_DOT_PRODUCT\n"
"src0_read += TILE_K;\n"
"slm_brow0 += TILE_K;\n"
"w += TILE_K;\n"
"}\n"
"src1_read0 += SLM_BLOCK;\n"
"}\n"
"if(w < K) {\n"
"float4 arow;\n"
"#define READ_BROW(_brow,_row) \\\n"
"_brow = vload4(0, slm_brow0 + _row * SLM_BLOCK); \\\n"
"_brow.x = (mad24(local_x, 4, w) < K) ? _brow.x : 0.0f; \\\n"
"_brow.y = (mad24(local_x, 4, w + 1) < K) ? _brow.y : 0.0f; \\\n"
"_brow.z = (mad24(local_x, 4, w + 2) < K) ? _brow.z : 0.0f; \\\n"
"_brow.w = (mad24(local_x, 4, w + 3) < K) ? _brow.w : 0.0f;\n"
"READ_BROW(brow0,0);\n"
"READ_BROW(brow1,1);\n"
"READ_BROW(brow2,2);\n"
"READ_BROW(brow3,3);\n"
"READ_BROW(brow4,4);\n"
"READ_BROW(brow5,5);\n"
"READ_BROW(brow6,6);\n"
"READ_BROW(brow7,7);\n"
"#define MM_DOT_PRODUCT(_row,_dot) \\\n"
"arow = vload4(0, src0_read + _row * ldA); \\\n"
"arow.x = (mad24(local_x, 4, w) < K) ? arow.x : 0.0f; \\\n"
"arow.y = (mad24(local_x, 4, w + 1) < K) ? arow.y : 0.0f; \\\n"
"arow.z = (mad24(local_x, 4, w + 2) < K) ? arow.z : 0.0f; \\\n"
"arow.w = (mad24(local_x, 4, w + 3) < K) ? arow.w : 0.0f; \\\n"
"_dot = mad( (float8)(arow.x), (float8)(brow0.x, brow1.x, brow2.x, brow3.x, brow4.x, brow5.x, brow6.x, brow7.x), _dot ); \\\n"
"_dot = mad( (float8)(arow.y), (float8)(brow0.y, brow1.y, brow2.y, brow3.y, brow4.y, brow5.y, brow6.y, brow7.y), _dot ); \\\n"
"_dot = mad( (float8)(arow.z), (float8)(brow0.z, brow1.z, brow2.z, brow3.z, brow4.z, brow5.z, brow6.z, brow7.z), _dot ); \\\n"
"_dot = mad( (float8)(arow.w), (float8)(brow0.w, brow1.w, brow2.w, brow3.w, brow4.w, brow5.w, brow6.w, brow7.w), _dot );\n"
"MM_DOT_PRODUCT(0,dot00);\n"
"MM_DOT_PRODUCT(1,dot01);\n"
"MM_DOT_PRODUCT(2,dot02);\n"
"MM_DOT_PRODUCT(3,dot03);\n"
"MM_DOT_PRODUCT(4,dot04);\n"
"MM_DOT_PRODUCT(5,dot05);\n"
"MM_DOT_PRODUCT(6,dot06);\n"
"MM_DOT_PRODUCT(7,dot07);\n"
"#undef MM_DOT_PRODUCT\n"
"}\n"
"#define REDUCE(_dot) \\\n"
"_dot.s0 = intel_sub_group_shuffle(_dot.s0, 0) + intel_sub_group_shuffle(_dot.s0, 1) + intel_sub_group_shuffle(_dot.s0, 2) + intel_sub_group_shuffle(_dot.s0, 3) + \\\n"
"intel_sub_group_shuffle(_dot.s0, 4) + intel_sub_group_shuffle(_dot.s0, 5) + intel_sub_group_shuffle(_dot.s0, 6) + intel_sub_group_shuffle(_dot.s0, 7); \\\n"
"_dot.s1 = intel_sub_group_shuffle(_dot.s1, 0) + intel_sub_group_shuffle(_dot.s1, 1) + intel_sub_group_shuffle(_dot.s1, 2) + intel_sub_group_shuffle(_dot.s1, 3) + \\\n"
"intel_sub_group_shuffle(_dot.s1, 4) + intel_sub_group_shuffle(_dot.s1, 5) + intel_sub_group_shuffle(_dot.s1, 6) + intel_sub_group_shuffle(_dot.s1, 7); \\\n"
"_dot.s2 = intel_sub_group_shuffle(_dot.s2, 0) + intel_sub_group_shuffle(_dot.s2, 1) + intel_sub_group_shuffle(_dot.s2, 2) + intel_sub_group_shuffle(_dot.s2, 3) + \\\n"
"intel_sub_group_shuffle(_dot.s2, 4) + intel_sub_group_shuffle(_dot.s2, 5) + intel_sub_group_shuffle(_dot.s2, 6) + intel_sub_group_shuffle(_dot.s2, 7); \\\n"
"_dot.s3 = intel_sub_group_shuffle(_dot.s3, 0) + intel_sub_group_shuffle(_dot.s3, 1) + intel_sub_group_shuffle(_dot.s3, 2) + intel_sub_group_shuffle(_dot.s3, 3) + \\\n"
"intel_sub_group_shuffle(_dot.s3, 4) + intel_sub_group_shuffle(_dot.s3, 5) + intel_sub_group_shuffle(_dot.s3, 6) + intel_sub_group_shuffle(_dot.s3, 7); \\\n"
"_dot.s4 = intel_sub_group_shuffle(_dot.s4, 0) + intel_sub_group_shuffle(_dot.s4, 1) + intel_sub_group_shuffle(_dot.s4, 2) + intel_sub_group_shuffle(_dot.s4, 3) + \\\n"
"intel_sub_group_shuffle(_dot.s4, 4) + intel_sub_group_shuffle(_dot.s4, 5) + intel_sub_group_shuffle(_dot.s4, 6) + intel_sub_group_shuffle(_dot.s4, 7); \\\n"
"_dot.s5 = intel_sub_group_shuffle(_dot.s5, 0) + intel_sub_group_shuffle(_dot.s5, 1) + intel_sub_group_shuffle(_dot.s5, 2) + intel_sub_group_shuffle(_dot.s5, 3) + \\\n"
"intel_sub_group_shuffle(_dot.s5, 4) + intel_sub_group_shuffle(_dot.s5, 5) + intel_sub_group_shuffle(_dot.s5, 6) + intel_sub_group_shuffle(_dot.s5, 7); \\\n"
"_dot.s6 = intel_sub_group_shuffle(_dot.s6, 0) + intel_sub_group_shuffle(_dot.s6, 1) + intel_sub_group_shuffle(_dot.s6, 2) + intel_sub_group_shuffle(_dot.s6, 3) + \\\n"
"intel_sub_group_shuffle(_dot.s6, 4) + intel_sub_group_shuffle(_dot.s6, 5) + intel_sub_group_shuffle(_dot.s6, 6) + intel_sub_group_shuffle(_dot.s6, 7); \\\n"
"_dot.s7 = intel_sub_group_shuffle(_dot.s7, 0) + intel_sub_group_shuffle(_dot.s7, 1) + intel_sub_group_shuffle(_dot.s7, 2) + intel_sub_group_shuffle(_dot.s7, 3) + \\\n"
"intel_sub_group_shuffle(_dot.s7, 4) + intel_sub_group_shuffle(_dot.s7, 5) + intel_sub_group_shuffle(_dot.s7, 6) + intel_sub_group_shuffle(_dot.s7, 7);\n"
"REDUCE(dot00);\n"
"REDUCE(dot01);\n"
"REDUCE(dot02);\n"
"REDUCE(dot03);\n"
"REDUCE(dot04);\n"
"REDUCE(dot05);\n"
"REDUCE(dot06);\n"
"REDUCE(dot07);\n"
"#undef REDUCE\n"
"float output = 0.0f;\n"
"#define OUTPUT(_dot) \\\n"
"output = (local_x == 0) ? _dot.s0 : output; \\\n"
"output = (local_x == 1) ? _dot.s1 : output; \\\n"
"output = (local_x == 2) ? _dot.s2 : output; \\\n"
"output = (local_x == 3) ? _dot.s3 : output; \\\n"
"output = (local_x == 4) ? _dot.s4 : output; \\\n"
"output = (local_x == 5) ? _dot.s5 : output; \\\n"
"output = (local_x == 6) ? _dot.s6 : output; \\\n"
"output = (local_x == 7) ? _dot.s7 : output; \\\n"
"if (beta != 0.0) \\\n"
"dst_write0[0] = mad(output, (float)alpha, ((float)beta * dst_write0[0])); \\\n"
"else \\\n"
"dst_write0[0] = output * (float)alpha; \\\n"
"dst_write0 += ldC;\n"
"if(global_x < N && global_y * 8 < M) {\n"
"OUTPUT(dot00);\n"
"if(mad24(global_y, 8, 1) < M) { OUTPUT(dot01); }\n"
"if(mad24(global_y, 8, 2) < M) { OUTPUT(dot02); }\n"
"if(mad24(global_y, 8, 3) < M) { OUTPUT(dot03); }\n"
"if(mad24(global_y, 8, 4) < M) { OUTPUT(dot04); }\n"
"if(mad24(global_y, 8, 5) < M) { OUTPUT(dot05); }\n"
"if(mad24(global_y, 8, 6) < M) { OUTPUT(dot06); }\n"
"if(mad24(global_y, 8, 7) < M) { OUTPUT(dot07); }\n"
"}\n"
"#undef OUTPUT\n"
"}\n"
"#undef VEC_SIZE\n"
"#undef LWG_HEIGHT\n"
"#undef TILE_M\n"
"#undef TILE_K\n"
"#undef TILE_N\n"
"#undef SLM_BLOCK\n"
"#define VEC_SIZE 4\n"
"#define LWG_HEIGHT 4\n"
"#define TILE_M 8\n"
"#define TILE_K 16\n"
"#define TILE_N 32\n"
"__attribute__((reqd_work_group_size(8, LWG_HEIGHT, 1)))\n"
"__kernel void intelblas_gemm_buffer_TN(\n"
"const __global float *src0, int off0,\n"
"const __global float *src1, int off1,\n"
"__global float *dst, int offd,\n"
"int M,\n"
"int N,\n"
"int K,\n"
"float alpha,\n"
"float beta,\n"
"int ldA,\n"
"int ldB,\n"
"int ldC,\n"
"int start_index,\n"
"int stride)\n"
"{\n"
"const int group_x = get_group_id(0);\n"
"const int group_y = get_group_id(1);\n"
"const int local_x = get_local_id(0);\n"
"const int local_y = get_local_id(1);\n"
"const int global_x = get_global_id(0);\n"
"const int global_y = get_global_id(1);\n"
"float4 brow;\n"
"__global float *dst_write0 = dst + local_x * VEC_SIZE + ( group_x * TILE_N ) + ( group_y * LWG_HEIGHT * TILE_M + local_y * TILE_M) * ldC + offd;\n"
"const __global float *src0_read = src0 + (local_x * ( TILE_K / 8 ) + start_index) * ldA + group_y * LWG_HEIGHT * TILE_M + local_y * TILE_M + off0;\n"
"const __global float *src1_read0 = src1 + local_x * VEC_SIZE + ( group_x * TILE_N ) + start_index * ldB + off1;\n"
"float4 dot00 = (start_index != 0) ? vload4(0, dst_write0) : ((beta != 0.0) ? ((float)beta * vload4(0, dst_write0 )) : (float4)(0.0));\n"
"float4 dot01 = (start_index != 0) ? vload4(0, dst_write0 + 1 * ldC) : ((beta != 0.0) ? ((float)beta * vload4(0, dst_write0 + 1 * ldC)) : (float4)(0.0));\n"
"float4 dot02 = (start_index != 0) ? vload4(0, dst_write0 + 2 * ldC) : ((beta != 0.0) ? ((float)beta * vload4(0, dst_write0 + 2 * ldC)) : (float4)(0.0));\n"
"float4 dot03 = (start_index != 0) ? vload4(0, dst_write0 + 3 * ldC) : ((beta != 0.0) ? ((float)beta * vload4(0, dst_write0 + 3 * ldC)) : (float4)(0.0));\n"
"float4 dot04 = (start_index != 0) ? vload4(0, dst_write0 + 4 * ldC) : ((beta != 0.0) ? ((float)beta * vload4(0, dst_write0 + 4 * ldC)) : (float4)(0.0));\n"
"float4 dot05 = (start_index != 0) ? vload4(0, dst_write0 + 5 * ldC) : ((beta != 0.0) ? ((float)beta * vload4(0, dst_write0 + 5 * ldC)) : (float4)(0.0));\n"
"float4 dot06 = (start_index != 0) ? vload4(0, dst_write0 + 6 * ldC) : ((beta != 0.0) ? ((float)beta * vload4(0, dst_write0 + 6 * ldC)) : (float4)(0.0));\n"
"float4 dot07 = (start_index != 0) ? vload4(0, dst_write0 + 7 * ldC) : ((beta != 0.0) ? ((float)beta * vload4(0, dst_write0 + 7 * ldC)) : (float4)(0.0));\n"
"int end_index = min(start_index + stride, K);\n"
"while( start_index + TILE_K <= end_index ) {\n"
"float8 arow0 = (float)alpha * vload8(0, src0_read);\n"
"float8 arow1 = (float)alpha * vload8(0, src0_read + ldA);\n"
"#define MM_DOT_PRODUCT(_arow,index) \\\n"
"brow = vload4(0, src1_read0); src1_read0 += ldB; \\\n"
"dot00 = mad( (float4)(intel_sub_group_shuffle(_arow.s0, index)), brow, dot00 ); \\\n"
"dot01 = mad( (float4)(intel_sub_group_shuffle(_arow.s1, index)), brow, dot01 ); \\\n"
"dot02 = mad( (float4)(intel_sub_group_shuffle(_arow.s2, index)), brow, dot02 ); \\\n"
"dot03 = mad( (float4)(intel_sub_group_shuffle(_arow.s3, index)), brow, dot03 ); \\\n"
"dot04 = mad( (float4)(intel_sub_group_shuffle(_arow.s4, index)), brow, dot04 ); \\\n"
"dot05 = mad( (float4)(intel_sub_group_shuffle(_arow.s5, index)), brow, dot05 ); \\\n"
"dot06 = mad( (float4)(intel_sub_group_shuffle(_arow.s6, index)), brow, dot06 ); \\\n"
"dot07 = mad( (float4)(intel_sub_group_shuffle(_arow.s7, index)), brow, dot07 );\n"
"MM_DOT_PRODUCT(arow0,0);\n"
"MM_DOT_PRODUCT(arow1,0);\n"
"MM_DOT_PRODUCT(arow0,1);\n"
"MM_DOT_PRODUCT(arow1,1);\n"
"MM_DOT_PRODUCT(arow0,2);\n"
"MM_DOT_PRODUCT(arow1,2);\n"
"MM_DOT_PRODUCT(arow0,3);\n"
"MM_DOT_PRODUCT(arow1,3);\n"
"MM_DOT_PRODUCT(arow0,4);\n"
"MM_DOT_PRODUCT(arow1,4);\n"
"MM_DOT_PRODUCT(arow0,5);\n"
"MM_DOT_PRODUCT(arow1,5);\n"
"MM_DOT_PRODUCT(arow0,6);\n"
"MM_DOT_PRODUCT(arow1,6);\n"
"MM_DOT_PRODUCT(arow0,7);\n"
"MM_DOT_PRODUCT(arow1,7);\n"
"#undef MM_DOT_PRODUCT\n"
"src0_read += TILE_K * ldA;\n"
"start_index += TILE_K;\n"
"}\n"
"if(start_index < end_index) {\n"
"float8 arow0 = ((start_index + local_x * 2) < K) ? ((float)alpha * vload8(0, src0_read)) : (float)0.0f;\n"
"float8 arow1 = ((start_index + local_x * 2 + 1) < K) ? ((float)alpha * vload8(0, src0_read + ldA)) : (float)0.0f;\n"
"#define MM_DOT_PRODUCT(_arow,index) \\\n"
"brow = (start_index < K) ? vload4(0, src1_read0) : (float)0.0f; src1_read0 += ldB; start_index++; \\\n"
"dot00 = mad( (float4)(intel_sub_group_shuffle(_arow.s0, index)), brow, dot00 ); \\\n"
"dot01 = mad( (float4)(intel_sub_group_shuffle(_arow.s1, index)), brow, dot01 ); \\\n"
"dot02 = mad( (float4)(intel_sub_group_shuffle(_arow.s2, index)), brow, dot02 ); \\\n"
"dot03 = mad( (float4)(intel_sub_group_shuffle(_arow.s3, index)), brow, dot03 ); \\\n"
"dot04 = mad( (float4)(intel_sub_group_shuffle(_arow.s4, index)), brow, dot04 ); \\\n"
"dot05 = mad( (float4)(intel_sub_group_shuffle(_arow.s5, index)), brow, dot05 ); \\\n"
"dot06 = mad( (float4)(intel_sub_group_shuffle(_arow.s6, index)), brow, dot06 ); \\\n"
"dot07 = mad( (float4)(intel_sub_group_shuffle(_arow.s7, index)), brow, dot07 );\n"
"MM_DOT_PRODUCT(arow0,0);\n"
"MM_DOT_PRODUCT(arow1,0);\n"
"MM_DOT_PRODUCT(arow0,1);\n"
"MM_DOT_PRODUCT(arow1,1);\n"
"MM_DOT_PRODUCT(arow0,2);\n"
"MM_DOT_PRODUCT(arow1,2);\n"
"MM_DOT_PRODUCT(arow0,3);\n"
"MM_DOT_PRODUCT(arow1,3);\n"
"MM_DOT_PRODUCT(arow0,4);\n"
"MM_DOT_PRODUCT(arow1,4);\n"
"MM_DOT_PRODUCT(arow0,5);\n"
"MM_DOT_PRODUCT(arow1,5);\n"
"MM_DOT_PRODUCT(arow0,6);\n"
"MM_DOT_PRODUCT(arow1,6);\n"
"MM_DOT_PRODUCT(arow0,7);\n"
"MM_DOT_PRODUCT(arow1,7);\n"
"#undef MM_DOT_PRODUCT\n"
"}\n"
"if(global_x * 4 < N && global_y * 8 < M) {\n"
"if(mad24(global_x, 4, 3) < N) {\n"
"vstore4(dot00, 0, dst_write0); dst_write0 += ldC;\n"
"if(mad24(global_y, 8, 1) < M) { vstore4(dot01, 0, dst_write0); dst_write0 += ldC; }\n"
"else return;\n"
"if(mad24(global_y, 8, 2) < M) { vstore4(dot02, 0, dst_write0); dst_write0 += ldC; }\n"
"else return;\n"
"if(mad24(global_y, 8, 3) < M) { vstore4(dot03, 0, dst_write0); dst_write0 += ldC; }\n"
"else return;\n"
"if(mad24(global_y, 8, 4) < M) { vstore4(dot04, 0, dst_write0); dst_write0 += ldC; }\n"
"else return;\n"
"if(mad24(global_y, 8, 5) < M) { vstore4(dot05, 0, dst_write0); dst_write0 += ldC; }\n"
"else return;\n"
"if(mad24(global_y, 8, 6) < M) { vstore4(dot06, 0, dst_write0); dst_write0 += ldC; }\n"
"else return;\n"
"if(mad24(global_y, 8, 7) < M) { vstore4(dot07, 0, dst_write0); }\n"
"} else if(mad24(global_x, 4, 2) < N) {\n"
"vstore2(dot00.xy, 0, dst_write0);\n"
"dst_write0[2] = dot00.z;\n"
"dst_write0 += ldC;\n"
"if(mad24(global_y, 8, 1) < M) {\n"
"vstore2(dot01.xy, 0, dst_write0);\n"
"dst_write0[2] = dot01.z;\n"
"dst_write0 += ldC;\n"
"} else\n"
"return;\n"
"if(mad24(global_y, 8, 2) < M) {\n"
"vstore2(dot02.xy, 0, dst_write0);\n"
"dst_write0[2] = dot02.z;\n"
"dst_write0 += ldC;\n"
"} else\n"
"return;\n"
"if(mad24(global_y, 8, 3) < M) {\n"
"vstore2(dot03.xy, 0, dst_write0);\n"
"dst_write0[2] = dot03.z;\n"
"dst_write0 += ldC;\n"
"} else\n"
"return;\n"
"if(mad24(global_y, 8, 4) < M) {\n"
"vstore2(dot04.xy, 0, dst_write0);\n"
"dst_write0[2] = dot04.z;\n"
"dst_write0 += ldC;\n"
"} else\n"
"return;\n"
"if(mad24(global_y, 8, 5) < M) {\n"
"vstore2(dot05.xy, 0, dst_write0);\n"
"dst_write0[2] = dot05.z;\n"
"dst_write0 += ldC;\n"
"} else\n"
"return;\n"
"if(mad24(global_y, 8, 6) < M) {\n"
"vstore2(dot06.xy, 0, dst_write0);\n"
"dst_write0[2] = dot06.z;\n"
"dst_write0 += ldC;\n"
"} else\n"
"return;\n"
"if(mad24(global_y, 8, 7) < M) {\n"
"vstore2(dot07.xy, 0, dst_write0);\n"
"dst_write0[2] = dot07.z;\n"
"}\n"
"} else if(mad24(global_x, 4, 1) < N) {\n"
"vstore2(dot00.xy, 0, dst_write0); dst_write0 += ldC;\n"
"if(mad24(global_y, 8, 1) < M) { vstore2(dot01.xy, 0, dst_write0); dst_write0 += ldC; }\n"
"else return;\n"
"if(mad24(global_y, 8, 2) < M) { vstore2(dot02.xy, 0, dst_write0); dst_write0 += ldC; }\n"
"else return;\n"
"if(mad24(global_y, 8, 3) < M) { vstore2(dot03.xy, 0, dst_write0); dst_write0 += ldC; }\n"
"else return;\n"
"if(mad24(global_y, 8, 4) < M) { vstore2(dot04.xy, 0, dst_write0); dst_write0 += ldC; }\n"
"else return;\n"
"if(mad24(global_y, 8, 5) < M) { vstore2(dot05.xy, 0, dst_write0); dst_write0 += ldC; }\n"
"else return;\n"
"if(mad24(global_y, 8, 6) < M) { vstore2(dot06.xy, 0, dst_write0); dst_write0 += ldC; }\n"
"else return;\n"
"if(mad24(global_y, 8, 7) < M) { vstore2(dot07.xy, 0, dst_write0); }\n"
"} else {\n"
"dst_write0[0] = dot00.x; dst_write0 += ldC;\n"
"if(mad24(global_y, 8, 1) < M) { dst_write0[0] = dot01.x; dst_write0 += ldC; }\n"
"else return;\n"
"if(mad24(global_y, 8, 2) < M) { dst_write0[0] = dot02.x; dst_write0 += ldC; }\n"
"else return;\n"
"if(mad24(global_y, 8, 3) < M) { dst_write0[0] = dot03.x; dst_write0 += ldC; }\n"
"else return;\n"
"if(mad24(global_y, 8, 4) < M) { dst_write0[0] = dot04.x; dst_write0 += ldC; }\n"
"else return;\n"
"if(mad24(global_y, 8, 5) < M) { dst_write0[0] = dot05.x; dst_write0 += ldC; }\n"
"else return;\n"
"if(mad24(global_y, 8, 6) < M) { dst_write0[0] = dot06.x; dst_write0 += ldC; }\n"
"else return;\n"
"if(mad24(global_y, 8, 7) < M) { dst_write0[0] = dot07.x; }\n"
"}\n"
"}\n"
"}\n"
"#undef VEC_SIZE\n"
"#undef LWG_HEIGHT\n"
"#undef TILE_M\n"
"#undef TILE_K\n"
"#undef TILE_N\n"
"#define VEC_SIZE 4\n"
"#define LWG_HEIGHT 4\n"
"#define TILE_M 8\n"
"#define TILE_K 16\n"
"#define TILE_N 32\n"
"__attribute__((reqd_work_group_size(8, LWG_HEIGHT, 1)))\n"
"__kernel void intelblas_gemm_buffer_TT(\n"
"const __global float *src0, int off0,\n"
"const __global float *src1, int off1,\n"
"__global float *dst, int offd,\n"
"int M,\n"
"int N,\n"
"int K,\n"
"float alpha,\n"
"float beta,\n"
"int ldA,\n"
"int ldB,\n"
"int ldC,\n"
"int start_index,\n"
"int stride)\n"
"{\n"
"const int group_x = get_group_id(0);\n"
"const int group_y = get_group_id(1);\n"
"const int local_x = get_local_id(0);\n"
"const int local_y = get_local_id(1);\n"
"const int global_x = get_global_id(0);\n"
"const int global_y = get_global_id(1);\n"
"float8 dot0 = 0.f;\n"
"float8 dot1 = 0.f;\n"
"float8 dot2 = 0.f;\n"
"float8 dot3 = 0.f;\n"
"float16 brow0;\n"
"float16 brow1;\n"
"float16 brow2;\n"
"float16 brow3;\n"
"__global float *dst_write0 = dst + local_x * VEC_SIZE + ( group_x * TILE_N ) + ( group_y * LWG_HEIGHT * TILE_M + local_y * TILE_M) * ldC + offd;\n"
"const __global float *src0_read = src0 + (local_x * ( TILE_K / 8 ) + start_index) * ldA + group_y * LWG_HEIGHT * TILE_M + local_y * TILE_M + off0;\n"
"const __global float *src1_read0 = src1 + (local_x * VEC_SIZE + ( group_x * TILE_N )) * ldB + start_index + off1;\n"
"float4 dot00 = (start_index != 0) ? vload4(0, dst_write0) : ((beta != 0.0)? ((float)beta * vload4(0, dst_write0 )) : (float4)(0.0));\n"
"float4 dot01 = (start_index != 0) ? vload4(0, dst_write0 + ldC) : ((beta != 0.0)? ((float)beta * vload4(0, dst_write0 + ldC )) : (float4)(0.0));\n"
"float4 dot02 = (start_index != 0) ? vload4(0, dst_write0 + 2 * ldC) : ((beta != 0.0)? ((float)beta * vload4(0, dst_write0 + 2 * ldC)) : (float4)(0.0));\n"
"float4 dot03 = (start_index != 0) ? vload4(0, dst_write0 + 3 * ldC) : ((beta != 0.0)? ((float)beta * vload4(0, dst_write0 + 3 * ldC)) : (float4)(0.0));\n"
"float4 dot04 = (start_index != 0) ? vload4(0, dst_write0 + 4 * ldC) : ((beta != 0.0)? ((float)beta * vload4(0, dst_write0 + 4 * ldC)) : (float4)(0.0));\n"
"float4 dot05 = (start_index != 0) ? vload4(0, dst_write0 + 5 * ldC) : ((beta != 0.0)? ((float)beta * vload4(0, dst_write0 + 5 * ldC)) : (float4)(0.0));\n"
"float4 dot06 = (start_index != 0) ? vload4(0, dst_write0 + 6 * ldC) : ((beta != 0.0)? ((float)beta * vload4(0, dst_write0 + 6 * ldC)) : (float4)(0.0));\n"
"float4 dot07 = (start_index != 0) ? vload4(0, dst_write0 + 7 * ldC) : ((beta != 0.0)? ((float)beta * vload4(0, dst_write0 + 7 * ldC)) : (float4)(0.0));\n"
"int end_index = min(start_index + stride, K);\n"
"while( start_index + TILE_K <= end_index ) {\n"
"brow0 = vload16(0, src1_read0);\n"
"brow1 = vload16(0, src1_read0 + ldB);\n"
"brow2 = vload16(0, src1_read0 + 2 * ldB);\n"
"brow3 = vload16(0, src1_read0 + 3 * ldB);\n"
"float8 arow0 = (float)alpha * vload8(0, src0_read);\n"
"float8 arow1 = (float)alpha * vload8(0, src0_read + ldA);\n"
"#define DOT_PRODUCT( _dot, _arow, index, _brow) \\\n"
"_dot.s0 = mad( intel_sub_group_shuffle( _arow.s0, index ), _brow, _dot.s0 ); \\\n"
"_dot.s1 = mad( intel_sub_group_shuffle( _arow.s1, index ), _brow, _dot.s1 ); \\\n"
"_dot.s2 = mad( intel_sub_group_shuffle( _arow.s2, index ), _brow, _dot.s2 ); \\\n"
"_dot.s3 = mad( intel_sub_group_shuffle( _arow.s3, index ), _brow, _dot.s3 ); \\\n"
"_dot.s4 = mad( intel_sub_group_shuffle( _arow.s4, index ), _brow, _dot.s4 ); \\\n"
"_dot.s5 = mad( intel_sub_group_shuffle( _arow.s5, index ), _brow, _dot.s5 ); \\\n"
"_dot.s6 = mad( intel_sub_group_shuffle( _arow.s6, index ), _brow, _dot.s6 ); \\\n"
"_dot.s7 = mad( intel_sub_group_shuffle( _arow.s7, index ), _brow, _dot.s7 );\n"
"#define MM_DOT_PRODUCT( _brow, _dot) \\\n"
"DOT_PRODUCT(_dot, arow0, 0, _brow.s0); \\\n"
"DOT_PRODUCT(_dot, arow1, 0, _brow.s1); \\\n"
"DOT_PRODUCT(_dot, arow0, 1, _brow.s2); \\\n"
"DOT_PRODUCT(_dot, arow1, 1, _brow.s3); \\\n"
"DOT_PRODUCT(_dot, arow0, 2, _brow.s4); \\\n"
"DOT_PRODUCT(_dot, arow1, 2, _brow.s5); \\\n"
"DOT_PRODUCT(_dot, arow0, 3, _brow.s6); \\\n"
"DOT_PRODUCT(_dot, arow1, 3, _brow.s7); \\\n"
"DOT_PRODUCT(_dot, arow0, 4, _brow.s8); \\\n"
"DOT_PRODUCT(_dot, arow1, 4, _brow.s9); \\\n"
"DOT_PRODUCT(_dot, arow0, 5, _brow.sa); \\\n"
"DOT_PRODUCT(_dot, arow1, 5, _brow.sb); \\\n"
"DOT_PRODUCT(_dot, arow0, 6, _brow.sc); \\\n"
"DOT_PRODUCT(_dot, arow1, 6, _brow.sd); \\\n"
"DOT_PRODUCT(_dot, arow0, 7, _brow.se); \\\n"
"DOT_PRODUCT(_dot, arow1, 7, _brow.sf);\n"
"MM_DOT_PRODUCT( brow0, dot0 );\n"
"MM_DOT_PRODUCT( brow1, dot1 );\n"
"MM_DOT_PRODUCT( brow2, dot2 );\n"
"MM_DOT_PRODUCT( brow3, dot3 );\n"
"#undef MM_DOT_PRODUCT\n"
"#undef DOT_PRODUCT\n"
"src1_read0 += TILE_K;\n"
"src0_read += TILE_K * ldA;\n"
"start_index += TILE_K;\n"
"}\n"
"if(start_index < end_index) {\n"
"brow0 = vload16(0, src1_read0); src1_read0 += ldB;\n"
"brow1 = vload16(0, src1_read0); src1_read0 += ldB;\n"
"brow2 = vload16(0, src1_read0); src1_read0 += ldB;\n"
"brow3 = vload16(0, src1_read0);\n"
"float8 arow0 = (float)alpha * vload8(0, src0_read);\n"
"float8 arow1 = (float)alpha * vload8(0, src0_read + ldA);\n"
"#define DOT_PRODUCT( _dot, _arow, index, _brow) \\\n"
"_dot.s0 = (w < K) ? mad( intel_sub_group_shuffle( _arow.s0, index ), _brow, _dot.s0 ) : _dot.s0; \\\n"
"_dot.s1 = (w < K) ? mad( intel_sub_group_shuffle( _arow.s1, index ), _brow, _dot.s1 ) : _dot.s1; \\\n"
"_dot.s2 = (w < K) ? mad( intel_sub_group_shuffle( _arow.s2, index ), _brow, _dot.s2 ) : _dot.s2; \\\n"
"_dot.s3 = (w < K) ? mad( intel_sub_group_shuffle( _arow.s3, index ), _brow, _dot.s3 ) : _dot.s3; \\\n"
"_dot.s4 = (w < K) ? mad( intel_sub_group_shuffle( _arow.s4, index ), _brow, _dot.s4 ) : _dot.s4; \\\n"
"_dot.s5 = (w < K) ? mad( intel_sub_group_shuffle( _arow.s5, index ), _brow, _dot.s5 ) : _dot.s5; \\\n"
"_dot.s6 = (w < K) ? mad( intel_sub_group_shuffle( _arow.s6, index ), _brow, _dot.s6 ) : _dot.s6; \\\n"
"_dot.s7 = (w++ < K) ? mad( intel_sub_group_shuffle( _arow.s7, index ), _brow, _dot.s7 ) : _dot.s7;\n"
"#define MM_DOT_PRODUCT( _brow, _dot) \\\n"
"DOT_PRODUCT(_dot, arow0, 0, _brow.s0); \\\n"
"DOT_PRODUCT(_dot, arow1, 0, _brow.s1); \\\n"
"DOT_PRODUCT(_dot, arow0, 1, _brow.s2); \\\n"
"DOT_PRODUCT(_dot, arow1, 1, _brow.s3); \\\n"
"DOT_PRODUCT(_dot, arow0, 2, _brow.s4); \\\n"
"DOT_PRODUCT(_dot, arow1, 2, _brow.s5); \\\n"
"DOT_PRODUCT(_dot, arow0, 3, _brow.s6); \\\n"
"DOT_PRODUCT(_dot, arow1, 3, _brow.s7); \\\n"
"DOT_PRODUCT(_dot, arow0, 4, _brow.s8); \\\n"
"DOT_PRODUCT(_dot, arow1, 4, _brow.s9); \\\n"
"DOT_PRODUCT(_dot, arow0, 5, _brow.sa); \\\n"
"DOT_PRODUCT(_dot, arow1, 5, _brow.sb); \\\n"
"DOT_PRODUCT(_dot, arow0, 6, _brow.sc); \\\n"
"DOT_PRODUCT(_dot, arow1, 6, _brow.sd); \\\n"
"DOT_PRODUCT(_dot, arow0, 7, _brow.se); \\\n"
"DOT_PRODUCT(_dot, arow1, 7, _brow.sf);\n"
"int w = start_index;\n"
"MM_DOT_PRODUCT( brow0, dot0 );\n"
"w = start_index;\n"
"MM_DOT_PRODUCT( brow1, dot1 );\n"
"w = start_index;\n"
"MM_DOT_PRODUCT( brow2, dot2 );\n"
"w = start_index;\n"
"MM_DOT_PRODUCT( brow3, dot3 );\n"
"#undef MM_DOT_PRODUCT\n"
"#undef DOT_PRODUCT\n"
"}\n"
"dot00 += (float4)(dot0.s0, dot1.s0, dot2.s0, dot3.s0);\n"
"dot01 += (float4)(dot0.s1, dot1.s1, dot2.s1, dot3.s1);\n"
"dot02 += (float4)(dot0.s2, dot1.s2, dot2.s2, dot3.s2);\n"
"dot03 += (float4)(dot0.s3, dot1.s3, dot2.s3, dot3.s3);\n"
"dot04 += (float4)(dot0.s4, dot1.s4, dot2.s4, dot3.s4);\n"
"dot05 += (float4)(dot0.s5, dot1.s5, dot2.s5, dot3.s5);\n"
"dot06 += (float4)(dot0.s6, dot1.s6, dot2.s6, dot3.s6);\n"
"dot07 += (float4)(dot0.s7, dot1.s7, dot2.s7, dot3.s7);\n"
"if(global_x * 4 < N && global_y * 8 < M) {\n"
"if(mad24(global_x, 4, 3) < N) {\n"
"vstore4(dot00, 0, dst_write0); dst_write0 += ldC;\n"
"if(mad24(global_y, 8, 1) < M) { vstore4(dot01, 0, dst_write0); dst_write0 += ldC; }\n"
"else return;\n"
"if(mad24(global_y, 8, 2) < M) { vstore4(dot02, 0, dst_write0); dst_write0 += ldC; }\n"
"else return;\n"
"if(mad24(global_y, 8, 3) < M) { vstore4(dot03, 0, dst_write0); dst_write0 += ldC; }\n"
"else return;\n"
"if(mad24(global_y, 8, 4) < M) { vstore4(dot04, 0, dst_write0); dst_write0 += ldC; }\n"
"else return;\n"
"if(mad24(global_y, 8, 5) < M) { vstore4(dot05, 0, dst_write0); dst_write0 += ldC; }\n"
"else return;\n"
"if(mad24(global_y, 8, 6) < M) { vstore4(dot06, 0, dst_write0); dst_write0 += ldC; }\n"
"else return;\n"
"if(mad24(global_y, 8, 7) < M) { vstore4(dot07, 0, dst_write0); }\n"
"} else if(mad24(global_x, 4, 2) < N) {\n"
"vstore2(dot00.xy, 0, dst_write0);\n"
"dst_write0[2] = dot00.z;\n"
"dst_write0 += ldC;\n"
"if(mad24(global_y, 8, 1) < M) {\n"
"vstore2(dot01.xy, 0, dst_write0);\n"
"dst_write0[2] = dot01.z;\n"
"dst_write0 += ldC;\n"
"} else\n"
"return;\n"
"if(mad24(global_y, 8, 2) < M) {\n"
"vstore2(dot02.xy, 0, dst_write0);\n"
"dst_write0[2] = dot02.z;\n"
"dst_write0 += ldC;\n"
"} else\n"
"return;\n"
"if(mad24(global_y, 8, 3) < M) {\n"
"vstore2(dot03.xy, 0, dst_write0);\n"
"dst_write0[2] = dot03.z;\n"
"dst_write0 += ldC;\n"
"} else\n"
"return;\n"
"if(mad24(global_y, 8, 4) < M) {\n"
"vstore2(dot04.xy, 0, dst_write0);\n"
"dst_write0[2] = dot04.z;\n"
"dst_write0 += ldC;\n"
"} else\n"
"return;\n"
"if(mad24(global_y, 8, 5) < M) {\n"
"vstore2(dot05.xy, 0, dst_write0);\n"
"dst_write0[2] = dot05.z;\n"
"dst_write0 += ldC;\n"
"} else\n"
"return;\n"
"if(mad24(global_y, 8, 6) < M) {\n"
"vstore2(dot06.xy, 0, dst_write0);\n"
"dst_write0[2] = dot06.z;\n"
"dst_write0 += ldC;\n"
"} else\n"
"return;\n"
"if(mad24(global_y, 8, 7) < M) {\n"
"vstore2(dot07.xy, 0, dst_write0);\n"
"dst_write0[2] = dot07.z;\n"
"}\n"
"} else if(mad24(global_x, 4, 1) < N) {\n"
"vstore2(dot00.xy, 0, dst_write0); dst_write0 += ldC;\n"
"if(mad24(global_y, 8, 1) < M) { vstore2(dot01.xy, 0, dst_write0); dst_write0 += ldC; }\n"
"else return;\n"
"if(mad24(global_y, 8, 2) < M) { vstore2(dot02.xy, 0, dst_write0); dst_write0 += ldC; }\n"
"else return;\n"
"if(mad24(global_y, 8, 3) < M) { vstore2(dot03.xy, 0, dst_write0); dst_write0 += ldC; }\n"
"else return;\n"
"if(mad24(global_y, 8, 4) < M) { vstore2(dot04.xy, 0, dst_write0); dst_write0 += ldC; }\n"
"else return;\n"
"if(mad24(global_y, 8, 5) < M) { vstore2(dot05.xy, 0, dst_write0); dst_write0 += ldC; }\n"
"else return;\n"
"if(mad24(global_y, 8, 6) < M) { vstore2(dot06.xy, 0, dst_write0); dst_write0 += ldC; }\n"
"else return;\n"
"if(mad24(global_y, 8, 7) < M) { vstore2(dot07.xy, 0, dst_write0); }\n"
"} else {\n"
"dst_write0[0] = dot00.x; dst_write0 += ldC;\n"
"if(mad24(global_y, 8, 1) < M) { dst_write0[0] = dot01.x; dst_write0 += ldC; }\n"
"else return;\n"
"if(mad24(global_y, 8, 2) < M) { dst_write0[0] = dot02.x; dst_write0 += ldC; }\n"
"else return;\n"
"if(mad24(global_y, 8, 3) < M) { dst_write0[0] = dot03.x; dst_write0 += ldC; }\n"
"else return;\n"
"if(mad24(global_y, 8, 4) < M) { dst_write0[0] = dot04.x; dst_write0 += ldC; }\n"
"else return;\n"
"if(mad24(global_y, 8, 5) < M) { dst_write0[0] = dot05.x; dst_write0 += ldC; }\n"
"else return;\n"
"if(mad24(global_y, 8, 6) < M) { dst_write0[0] = dot06.x; dst_write0 += ldC; }\n"
"else return;\n"
"if(mad24(global_y, 8, 7) < M) { dst_write0[0] = dot07.x; }\n"
"}\n"
"}\n"
"}\n"
"#undef VEC_SIZE\n"
"#undef LWG_HEIGHT\n"
"#undef TILE_M\n"
"#undef TILE_K\n"
"#undef TILE_N\n"
"#endif\n"
, "b63452038412af8debb5e7a0a7de9292", NULL};
struct cv::ocl::internal::ProgramEntry lut_oclsrc={moduleName, "lut",
"#if lcn == 1\n"
"#if dcn == 4\n"
"#define LUT_OP \\\n"
"int idx = *(__global const int *)(srcptr + src_index); \\\n"
"dst = (__global dstT *)(dstptr + dst_index); \\\n"
"dst[0] = lut_l[idx & 0xff]; \\\n"
"dst[1] = lut_l[(idx >> 8) & 0xff]; \\\n"
"dst[2] = lut_l[(idx >> 16) & 0xff]; \\\n"
"dst[3] = lut_l[(idx >> 24) & 0xff];\n"
"#elif dcn == 3\n"
"#define LUT_OP \\\n"
"uchar3 idx = vload3(0, srcptr + src_index); \\\n"
"dst = (__global dstT *)(dstptr + dst_index); \\\n"
"dst[0] = lut_l[idx.x]; \\\n"
"dst[1] = lut_l[idx.y]; \\\n"
"dst[2] = lut_l[idx.z];\n"
"#elif dcn == 2\n"
"#define LUT_OP \\\n"
"short idx = *(__global const short *)(srcptr + src_index); \\\n"
"dst = (__global dstT *)(dstptr + dst_index); \\\n"
"dst[0] = lut_l[idx & 0xff]; \\\n"
"dst[1] = lut_l[(idx >> 8) & 0xff];\n"
"#elif dcn == 1\n"
"#define LUT_OP \\\n"
"uchar idx = (srcptr + src_index)[0]; \\\n"
"dst = (__global dstT *)(dstptr + dst_index); \\\n"
"dst[0] = lut_l[idx];\n"
"#else\n"
"#define LUT_OP \\\n"
"__global const srcT * src = (__global const srcT *)(srcptr + src_index); \\\n"
"dst = (__global dstT *)(dstptr + dst_index); \\\n"
"for (int cn = 0; cn < dcn; ++cn) \\\n"
"dst[cn] = lut_l[src[cn]];\n"
"#endif\n"
"#else\n"
"#if dcn == 4\n"
"#define LUT_OP \\\n"
"__global const uchar4 * src_pixel = (__global const uchar4 *)(srcptr + src_index); \\\n"
"int4 idx = mad24(convert_int4(src_pixel[0]), (int4)(lcn), (int4)(0, 1, 2, 3)); \\\n"
"dst = (__global dstT *)(dstptr + dst_index); \\\n"
"dst[0] = lut_l[idx.x]; \\\n"
"dst[1] = lut_l[idx.y]; \\\n"
"dst[2] = lut_l[idx.z]; \\\n"
"dst[3] = lut_l[idx.w];\n"
"#elif dcn == 3\n"
"#define LUT_OP \\\n"
"uchar3 src_pixel = vload3(0, srcptr + src_index); \\\n"
"int3 idx = mad24(convert_int3(src_pixel), (int3)(lcn), (int3)(0, 1, 2)); \\\n"
"dst = (__global dstT *)(dstptr + dst_index); \\\n"
"dst[0] = lut_l[idx.x]; \\\n"
"dst[1] = lut_l[idx.y]; \\\n"
"dst[2] = lut_l[idx.z];\n"
"#elif dcn == 2\n"
"#define LUT_OP \\\n"
"__global const uchar2 * src_pixel = (__global const uchar2 *)(srcptr + src_index); \\\n"
"int2 idx = mad24(convert_int2(src_pixel[0]), lcn, (int2)(0, 1)); \\\n"
"dst = (__global dstT *)(dstptr + dst_index); \\\n"
"dst[0] = lut_l[idx.x]; \\\n"
"dst[1] = lut_l[idx.y];\n"
"#elif dcn == 1\n"
"#define LUT_OP \\\n"
"uchar idx = (srcptr + src_index)[0]; \\\n"
"dst = (__global dstT *)(dstptr + dst_index); \\\n"
"dst[0] = lut_l[idx];\n"
"#else\n"
"#define LUT_OP \\\n"
"__global const srcT * src = (__global const srcT *)(srcptr + src_index); \\\n"
"dst = (__global dstT *)(dstptr + dst_index); \\\n"
"for (int cn = 0; cn < dcn; ++cn) \\\n"
"dst[cn] = lut_l[mad24(src[cn], lcn, cn)];\n"
"#endif\n"
"#endif\n"
"__kernel void LUT(__global const uchar * srcptr, int src_step, int src_offset,\n"
"__global const uchar * lutptr, int lut_step, int lut_offset,\n"
"__global uchar * dstptr, int dst_step, int dst_offset, int rows, int cols)\n"
"{\n"
"int x = get_global_id(0);\n"
"int y = get_global_id(1) << 2;\n"
"__local dstT lut_l[256 * lcn];\n"
"__global const dstT * lut = (__global const dstT *)(lutptr + lut_offset);\n"
"for (int i = mad24((int)get_local_id(1), (int)get_local_size(0), (int)get_local_id(0)),\n"
"step = get_local_size(0) * get_local_size(1); i < 256 * lcn; i += step)\n"
"lut_l[i] = lut[i];\n"
"barrier(CLK_LOCAL_MEM_FENCE);\n"
"if (x < cols && y < rows)\n"
"{\n"
"int src_index = mad24(y, src_step, mad24(x, (int)sizeof(srcT) * dcn, src_offset));\n"
"int dst_index = mad24(y, dst_step, mad24(x, (int)sizeof(dstT) * dcn, dst_offset));\n"
"__global dstT * dst;\n"
"LUT_OP;\n"
"if (y < rows - 1)\n"
"{\n"
"src_index += src_step;\n"
"dst_index += dst_step;\n"
"LUT_OP;\n"
"if (y < rows - 2)\n"
"{\n"
"src_index += src_step;\n"
"dst_index += dst_step;\n"
"LUT_OP;\n"
"if (y < rows - 3)\n"
"{\n"
"src_index += src_step;\n"
"dst_index += dst_step;\n"
"LUT_OP;\n"
"}\n"
"}\n"
"}\n"
"}\n"
"}\n"
, "02217d060320fc126306ad16885be711", NULL};
struct cv::ocl::internal::ProgramEntry meanstddev_oclsrc={moduleName, "meanstddev",
"#ifdef DOUBLE_SUPPORT\n"
"#ifdef cl_amd_fp64\n"
"#pragma OPENCL EXTENSION cl_amd_fp64:enable\n"
"#elif defined (cl_khr_fp64)\n"
"#pragma OPENCL EXTENSION cl_khr_fp64:enable\n"
"#endif\n"
"#endif\n"
"#define noconvert\n"
"#if cn != 3\n"
"#define loadpix(addr) *(__global const srcT *)(addr)\n"
"#define storepix(val, addr) *(__global dstT *)(addr) = val\n"
"#define storesqpix(val, addr) *(__global sqdstT *)(addr) = val\n"
"#define srcTSIZE (int)sizeof(srcT)\n"
"#define dstTSIZE (int)sizeof(dstT)\n"
"#define sqdstTSIZE (int)sizeof(sqdstT)\n"
"#else\n"
"#define loadpix(addr) vload3(0, (__global const srcT1 *)(addr))\n"
"#define storepix(val, addr) vstore3(val, 0, (__global dstT1 *)(addr))\n"
"#define storesqpix(val, addr) vstore3(val, 0, (__global sqdstT1 *)(addr))\n"
"#define srcTSIZE ((int)sizeof(srcT1)*3)\n"
"#define dstTSIZE ((int)sizeof(dstT1)*3)\n"
"#define sqdstTSIZE ((int)sizeof(sqdstT1)*3)\n"
"#endif\n"
"__kernel void meanStdDev(__global const uchar * srcptr, int src_step, int src_offset, int cols,\n"
"int total, int groups, __global uchar * dstptr\n"
"#ifdef HAVE_MASK\n"
", __global const uchar * mask, int mask_step, int mask_offset\n"
"#endif\n"
")\n"
"{\n"
"int lid = get_local_id(0);\n"
"int gid = get_group_id(0);\n"
"int id = get_global_id(0);\n"
"__local dstT localMemSum[WGS2_ALIGNED];\n"
"__local sqdstT localMemSqSum[WGS2_ALIGNED];\n"
"#ifdef HAVE_MASK\n"
"__local int localMemNonZero[WGS2_ALIGNED];\n"
"#endif\n"
"dstT accSum = (dstT)(0);\n"
"sqdstT accSqSum = (sqdstT)(0);\n"
"#ifdef HAVE_MASK\n"
"int accNonZero = 0;\n"
"mask += mask_offset;\n"
"#endif\n"
"srcptr += src_offset;\n"
"for (int grain = groups * WGS; id < total; id += grain)\n"
"{\n"
"#ifdef HAVE_MASK\n"
"#ifdef HAVE_MASK_CONT\n"
"int mask_index = id;\n"
"#else\n"
"int mask_index = mad24(id / cols, mask_step, id % cols);\n"
"#endif\n"
"if (mask[mask_index])\n"
"#endif\n"
"{\n"
"#ifdef HAVE_SRC_CONT\n"
"int src_index = id * srcTSIZE;\n"
"#else\n"
"int src_index = mad24(id / cols, src_step, mul24(id % cols, srcTSIZE));\n"
"#endif\n"
"srcT value = loadpix(srcptr + src_index);\n"
"accSum += convertToDT(value);\n"
"sqdstT dvalue = convertToSDT(value);\n"
"accSqSum = fma(dvalue, dvalue, accSqSum);\n"
"#ifdef HAVE_MASK\n"
"++accNonZero;\n"
"#endif\n"
"}\n"
"}\n"
"if (lid < WGS2_ALIGNED)\n"
"{\n"
"localMemSum[lid] = accSum;\n"
"localMemSqSum[lid] = accSqSum;\n"
"#ifdef HAVE_MASK\n"
"localMemNonZero[lid] = accNonZero;\n"
"#endif\n"
"}\n"
"barrier(CLK_LOCAL_MEM_FENCE);\n"
"if (lid >= WGS2_ALIGNED && total >= WGS2_ALIGNED)\n"
"{\n"
"localMemSum[lid - WGS2_ALIGNED] += accSum;\n"
"localMemSqSum[lid - WGS2_ALIGNED] += accSqSum;\n"
"#ifdef HAVE_MASK\n"
"localMemNonZero[lid - WGS2_ALIGNED] += accNonZero;\n"
"#endif\n"
"}\n"
"barrier(CLK_LOCAL_MEM_FENCE);\n"
"for (int lsize = WGS2_ALIGNED >> 1; lsize > 0; lsize >>= 1)\n"
"{\n"
"if (lid < lsize)\n"
"{\n"
"int lid2 = lsize + lid;\n"
"localMemSum[lid] += localMemSum[lid2];\n"
"localMemSqSum[lid] += localMemSqSum[lid2];\n"
"#ifdef HAVE_MASK\n"
"localMemNonZero[lid] += localMemNonZero[lid2];\n"
"#endif\n"
"}\n"
"barrier(CLK_LOCAL_MEM_FENCE);\n"
"}\n"
"if (lid == 0)\n"
"{\n"
"storepix(localMemSum[0], dstptr + dstTSIZE * gid);\n"
"storesqpix(localMemSqSum[0], dstptr + mad24(dstTSIZE, groups, sqdstTSIZE * gid));\n"
"#ifdef HAVE_MASK\n"
"*(__global int *)(dstptr + mad24(dstTSIZE + sqdstTSIZE, groups, (int)sizeof(int) * gid)) = localMemNonZero[0];\n"
"#endif\n"
"}\n"
"}\n"
, "1284edd21da32ce135cd26c0c897bd08", NULL};
struct cv::ocl::internal::ProgramEntry minmaxloc_oclsrc={moduleName, "minmaxloc",
"#ifdef DOUBLE_SUPPORT\n"
"#ifdef cl_amd_fp64\n"
"#pragma OPENCL EXTENSION cl_amd_fp64:enable\n"
"#elif defined (cl_khr_fp64)\n"
"#pragma OPENCL EXTENSION cl_khr_fp64:enable\n"
"#endif\n"
"#endif\n"
"static inline int align(int pos)\n"
"{\n"
"return (pos + (MINMAX_STRUCT_ALIGNMENT - 1)) & (~(MINMAX_STRUCT_ALIGNMENT - 1));\n"
"}\n"
"#ifdef DEPTH_0\n"
"#define MIN_VAL 0\n"
"#define MAX_VAL UCHAR_MAX\n"
"#elif defined DEPTH_1\n"
"#define MIN_VAL SCHAR_MIN\n"
"#define MAX_VAL SCHAR_MAX\n"
"#elif defined DEPTH_2\n"
"#define MIN_VAL 0\n"
"#define MAX_VAL USHRT_MAX\n"
"#elif defined DEPTH_3\n"
"#define MIN_VAL SHRT_MIN\n"
"#define MAX_VAL SHRT_MAX\n"
"#elif defined DEPTH_4\n"
"#define MIN_VAL INT_MIN\n"
"#define MAX_VAL INT_MAX\n"
"#elif defined DEPTH_5\n"
"#define MIN_VAL (-FLT_MAX)\n"
"#define MAX_VAL FLT_MAX\n"
"#elif defined DEPTH_6\n"
"#define MIN_VAL (-DBL_MAX)\n"
"#define MAX_VAL DBL_MAX\n"
"#endif\n"
"#define noconvert\n"
"#define INDEX_MAX UINT_MAX\n"
"#if wdepth <= 4\n"
"#define MIN_ABS(a) convertFromU(abs(a))\n"
"#define MIN_ABS2(a, b) convertFromU(abs_diff(a, b))\n"
"#define MIN(a, b) min(a, b)\n"
"#define MAX(a, b) max(a, b)\n"
"#else\n"
"#define MIN_ABS(a) fabs(a)\n"
"#define MIN_ABS2(a, b) fabs(a - b)\n"
"#define MIN(a, b) fmin(a, b)\n"
"#define MAX(a, b) fmax(a, b)\n"
"#endif\n"
"#if kercn != 3\n"
"#define loadpix(addr) *(__global const srcT *)(addr)\n"
"#define srcTSIZE (int)sizeof(srcT)\n"
"#else\n"
"#define loadpix(addr) vload3(0, (__global const srcT1 *)(addr))\n"
"#define srcTSIZE ((int)sizeof(srcT1) * 3)\n"
"#endif\n"
"#ifndef HAVE_MASK\n"
"#undef srcTSIZE\n"
"#define srcTSIZE (int)sizeof(srcT1)\n"
"#endif\n"
"#ifdef NEED_MINVAL\n"
"#ifdef NEED_MINLOC\n"
"#define CALC_MIN(p, inc) \\\n"
"if (minval > temp.p) \\\n"
"{ \\\n"
"minval = temp.p; \\\n"
"minloc = id + inc; \\\n"
"}\n"
"#else\n"
"#define CALC_MIN(p, inc) \\\n"
"minval = MIN(minval, temp.p);\n"
"#endif\n"
"#else\n"
"#define CALC_MIN(p, inc)\n"
"#endif\n"
"#ifdef NEED_MAXVAL\n"
"#ifdef NEED_MAXLOC\n"
"#define CALC_MAX(p, inc) \\\n"
"if (maxval < temp.p) \\\n"
"{ \\\n"
"maxval = temp.p; \\\n"
"maxloc = id + inc; \\\n"
"}\n"
"#else\n"
"#define CALC_MAX(p, inc) \\\n"
"maxval = MAX(maxval, temp.p);\n"
"#endif\n"
"#else\n"
"#define CALC_MAX(p, inc)\n"
"#endif\n"
"#ifdef OP_CALC2\n"
"#define CALC_MAX2(p) \\\n"
"maxval2 = MAX(maxval2, temp2.p);\n"
"#else\n"
"#define CALC_MAX2(p)\n"
"#endif\n"
"#define CALC_P(p, inc) \\\n"
"CALC_MIN(p, inc) \\\n"
"CALC_MAX(p, inc) \\\n"
"CALC_MAX2(p)\n"
"__kernel void minmaxloc(__global const uchar * srcptr, int src_step, int src_offset, int cols,\n"
"int total, int groupnum, __global uchar * dstptr\n"
"#ifdef HAVE_MASK\n"
", __global const uchar * mask, int mask_step, int mask_offset\n"
"#endif\n"
"#ifdef HAVE_SRC2\n"
", __global const uchar * src2ptr, int src2_step, int src2_offset\n"
"#endif\n"
")\n"
"{\n"
"int lid = get_local_id(0);\n"
"int gid = get_group_id(0);\n"
"int id = get_global_id(0)\n"
"#ifndef HAVE_MASK\n"
"* kercn;\n"
"#else\n"
";\n"
"#endif\n"
"srcptr += src_offset;\n"
"#ifdef HAVE_MASK\n"
"mask += mask_offset;\n"
"#endif\n"
"#ifdef HAVE_SRC2\n"
"src2ptr += src2_offset;\n"
"#endif\n"
"#ifdef NEED_MINVAL\n"
"__local dstT1 localmem_min[WGS2_ALIGNED];\n"
"dstT1 minval = MAX_VAL;\n"
"#ifdef NEED_MINLOC\n"
"__local uint localmem_minloc[WGS2_ALIGNED];\n"
"uint minloc = INDEX_MAX;\n"
"#endif\n"
"#endif\n"
"#ifdef NEED_MAXVAL\n"
"dstT1 maxval = MIN_VAL;\n"
"__local dstT1 localmem_max[WGS2_ALIGNED];\n"
"#ifdef NEED_MAXLOC\n"
"__local uint localmem_maxloc[WGS2_ALIGNED];\n"
"uint maxloc = INDEX_MAX;\n"
"#endif\n"
"#endif\n"
"#ifdef OP_CALC2\n"
"__local dstT1 localmem_max2[WGS2_ALIGNED];\n"
"dstT1 maxval2 = MIN_VAL;\n"
"#endif\n"
"int src_index;\n"
"#ifdef HAVE_MASK\n"
"int mask_index;\n"
"#endif\n"
"#ifdef HAVE_SRC2\n"
"int src2_index;\n"
"#endif\n"
"dstT temp;\n"
"#ifdef HAVE_SRC2\n"
"dstT temp2;\n"
"#endif\n"
"for (int grain = groupnum * WGS\n"
"#ifndef HAVE_MASK\n"
"* kercn\n"
"#endif\n"
"; id < total; id += grain)\n"
"{\n"
"#ifdef HAVE_MASK\n"
"#ifdef HAVE_MASK_CONT\n"
"mask_index = id;\n"
"#else\n"
"mask_index = mad24(id / cols, mask_step, id % cols);\n"
"#endif\n"
"if (mask[mask_index])\n"
"#endif\n"
"{\n"
"#ifdef HAVE_SRC_CONT\n"
"src_index = id * srcTSIZE;\n"
"#else\n"
"src_index = mad24(id / cols, src_step, mul24(id % cols, srcTSIZE));\n"
"#endif\n"
"temp = convertToDT(loadpix(srcptr + src_index));\n"
"#ifdef OP_ABS\n"
"temp = MIN_ABS(temp);\n"
"#endif\n"
"#ifdef HAVE_SRC2\n"
"#ifdef HAVE_SRC2_CONT\n"
"src2_index = id * srcTSIZE;\n"
"#else\n"
"src2_index = mad24(id / cols, src2_step, mul24(id % cols, srcTSIZE));\n"
"#endif\n"
"temp2 = convertToDT(loadpix(src2ptr + src2_index));\n"
"temp = MIN_ABS2(temp, temp2);\n"
"#ifdef OP_CALC2\n"
"temp2 = MIN_ABS(temp2);\n"
"#endif\n"
"#endif\n"
"#if kercn == 1\n"
"#ifdef NEED_MINVAL\n"
"#ifdef NEED_MINLOC\n"
"if (minval > temp)\n"
"{\n"
"minval = temp;\n"
"minloc = id;\n"
"}\n"
"#else\n"
"minval = MIN(minval, temp);\n"
"#endif\n"
"#endif\n"
"#ifdef NEED_MAXVAL\n"
"#ifdef NEED_MAXLOC\n"
"if (maxval < temp)\n"
"{\n"
"maxval = temp;\n"
"maxloc = id;\n"
"}\n"
"#else\n"
"maxval = MAX(maxval, temp);\n"
"#endif\n"
"#ifdef OP_CALC2\n"
"maxval2 = MAX(maxval2, temp2);\n"
"#endif\n"
"#endif\n"
"#elif kercn >= 2\n"
"CALC_P(s0, 0)\n"
"CALC_P(s1, 1)\n"
"#if kercn >= 3\n"
"CALC_P(s2, 2)\n"
"#if kercn >= 4\n"
"CALC_P(s3, 3)\n"
"#if kercn >= 8\n"
"CALC_P(s4, 4)\n"
"CALC_P(s5, 5)\n"
"CALC_P(s6, 6)\n"
"CALC_P(s7, 7)\n"
"#if kercn == 16\n"
"CALC_P(s8, 8)\n"
"CALC_P(s9, 9)\n"
"CALC_P(sA, 10)\n"
"CALC_P(sB, 11)\n"
"CALC_P(sC, 12)\n"
"CALC_P(sD, 13)\n"
"CALC_P(sE, 14)\n"
"CALC_P(sF, 15)\n"
"#endif\n"
"#endif\n"
"#endif\n"
"#endif\n"
"#endif\n"
"}\n"
"}\n"
"if (lid < WGS2_ALIGNED)\n"
"{\n"
"#ifdef NEED_MINVAL\n"
"localmem_min[lid] = minval;\n"
"#endif\n"
"#ifdef NEED_MAXVAL\n"
"localmem_max[lid] = maxval;\n"
"#endif\n"
"#ifdef NEED_MINLOC\n"
"localmem_minloc[lid] = minloc;\n"
"#endif\n"
"#ifdef NEED_MAXLOC\n"
"localmem_maxloc[lid] = maxloc;\n"
"#endif\n"
"#ifdef OP_CALC2\n"
"localmem_max2[lid] = maxval2;\n"
"#endif\n"
"}\n"
"barrier(CLK_LOCAL_MEM_FENCE);\n"
"if (lid >= WGS2_ALIGNED && total >= WGS2_ALIGNED)\n"
"{\n"
"int lid3 = lid - WGS2_ALIGNED;\n"
"#ifdef NEED_MINVAL\n"
"#ifdef NEED_MINLOC\n"
"if (localmem_min[lid3] >= minval)\n"
"{\n"
"if (localmem_min[lid3] == minval)\n"
"localmem_minloc[lid3] = min(localmem_minloc[lid3], minloc);\n"
"else\n"
"localmem_minloc[lid3] = minloc,\n"
"localmem_min[lid3] = minval;\n"
"}\n"
"#else\n"
"localmem_min[lid3] = MIN(localmem_min[lid3], minval);\n"
"#endif\n"
"#endif\n"
"#ifdef NEED_MAXVAL\n"
"#ifdef NEED_MAXLOC\n"
"if (localmem_max[lid3] <= maxval)\n"
"{\n"
"if (localmem_max[lid3] == maxval)\n"
"localmem_maxloc[lid3] = min(localmem_maxloc[lid3], maxloc);\n"
"else\n"
"localmem_maxloc[lid3] = maxloc,\n"
"localmem_max[lid3] = maxval;\n"
"}\n"
"#else\n"
"localmem_max[lid3] = MAX(localmem_max[lid3], maxval);\n"
"#endif\n"
"#endif\n"
"#ifdef OP_CALC2\n"
"localmem_max2[lid3] = MAX(localmem_max2[lid3], maxval2);\n"
"#endif\n"
"}\n"
"barrier(CLK_LOCAL_MEM_FENCE);\n"
"for (int lsize = WGS2_ALIGNED >> 1; lsize > 0; lsize >>= 1)\n"
"{\n"
"if (lid < lsize)\n"
"{\n"
"int lid2 = lsize + lid;\n"
"#ifdef NEED_MINVAL\n"
"#ifdef NEED_MINLOC\n"
"if (localmem_min[lid] >= localmem_min[lid2])\n"
"{\n"
"if (localmem_min[lid] == localmem_min[lid2])\n"
"localmem_minloc[lid] = min(localmem_minloc[lid2], localmem_minloc[lid]);\n"
"else\n"
"localmem_minloc[lid] = localmem_minloc[lid2],\n"
"localmem_min[lid] = localmem_min[lid2];\n"
"}\n"
"#else\n"
"localmem_min[lid] = MIN(localmem_min[lid], localmem_min[lid2]);\n"
"#endif\n"
"#endif\n"
"#ifdef NEED_MAXVAL\n"
"#ifdef NEED_MAXLOC\n"
"if (localmem_max[lid] <= localmem_max[lid2])\n"
"{\n"
"if (localmem_max[lid] == localmem_max[lid2])\n"
"localmem_maxloc[lid] = min(localmem_maxloc[lid2], localmem_maxloc[lid]);\n"
"else\n"
"localmem_maxloc[lid] = localmem_maxloc[lid2],\n"
"localmem_max[lid] = localmem_max[lid2];\n"
"}\n"
"#else\n"
"localmem_max[lid] = MAX(localmem_max[lid], localmem_max[lid2]);\n"
"#endif\n"
"#endif\n"
"#ifdef OP_CALC2\n"
"localmem_max2[lid] = MAX(localmem_max2[lid], localmem_max2[lid2]);\n"
"#endif\n"
"}\n"
"barrier(CLK_LOCAL_MEM_FENCE);\n"
"}\n"
"if (lid == 0)\n"
"{\n"
"int pos = 0;\n"
"#ifdef NEED_MINVAL\n"
"*(__global dstT1 *)(dstptr + mad24(gid, (int)sizeof(dstT1), pos)) = localmem_min[0];\n"
"pos = mad24(groupnum, (int)sizeof(dstT1), pos);\n"
"pos = align(pos);\n"
"#endif\n"
"#ifdef NEED_MAXVAL\n"
"*(__global dstT1 *)(dstptr + mad24(gid, (int)sizeof(dstT1), pos)) = localmem_max[0];\n"
"pos = mad24(groupnum, (int)sizeof(dstT1), pos);\n"
"pos = align(pos);\n"
"#endif\n"
"#ifdef NEED_MINLOC\n"
"*(__global uint *)(dstptr + mad24(gid, (int)sizeof(uint), pos)) = localmem_minloc[0];\n"
"pos = mad24(groupnum, (int)sizeof(uint), pos);\n"
"pos = align(pos);\n"
"#endif\n"
"#ifdef NEED_MAXLOC\n"
"*(__global uint *)(dstptr + mad24(gid, (int)sizeof(uint), pos)) = localmem_maxloc[0];\n"
"#ifdef OP_CALC2\n"
"pos = mad24(groupnum, (int)sizeof(uint), pos);\n"
"pos = align(pos);\n"
"#endif\n"
"#endif\n"
"#ifdef OP_CALC2\n"
"*(__global dstT1 *)(dstptr + mad24(gid, (int)sizeof(dstT1), pos)) = localmem_max2[0];\n"
"#endif\n"
"}\n"
"}\n"
, "db5f17eea45ac79530d7323906118580", NULL};
struct cv::ocl::internal::ProgramEntry mixchannels_oclsrc={moduleName, "mixchannels",
"#define DECLARE_INPUT_MAT(i) \\\n"
"__global const uchar * src##i##ptr, int src##i##_step, int src##i##_offset,\n"
"#define DECLARE_OUTPUT_MAT(i) \\\n"
"__global uchar * dst##i##ptr, int dst##i##_step, int dst##i##_offset,\n"
"#define DECLARE_INDEX(i) \\\n"
"int src##i##_index = mad24(src##i##_step, y0, mad24(x, (int)sizeof(T) * scn##i, src##i##_offset)); \\\n"
"int dst##i##_index = mad24(dst##i##_step, y0, mad24(x, (int)sizeof(T) * dcn##i, dst##i##_offset));\n"
"#define PROCESS_ELEM(i) \\\n"
"__global const T * src##i = (__global const T *)(src##i##ptr + src##i##_index); \\\n"
"__global T * dst##i = (__global T *)(dst##i##ptr + dst##i##_index); \\\n"
"dst##i[0] = src##i[0]; \\\n"
"src##i##_index += src##i##_step; \\\n"
"dst##i##_index += dst##i##_step;\n"
"__kernel void mixChannels(DECLARE_INPUT_MAT_N DECLARE_OUTPUT_MAT_N int rows, int cols, int rowsPerWI)\n"
"{\n"
"int x = get_global_id(0);\n"
"int y0 = get_global_id(1) * rowsPerWI;\n"
"if (x < cols)\n"
"{\n"
"DECLARE_INDEX_N\n"
"for (int y = y0, y1 = min(y0 + rowsPerWI, rows); y < y1; ++y)\n"
"{\n"
"PROCESS_ELEM_N\n"
"}\n"
"}\n"
"}\n"
, "26a27b81c3e2524a8eb918b3a518da0a", NULL};
struct cv::ocl::internal::ProgramEntry mulspectrums_oclsrc={moduleName, "mulspectrums",
"inline float2 cmulf(float2 a, float2 b)\n"
"{\n"
"return (float2)(mad(a.x, b.x, - a.y * b.y), mad(a.x, b.y, a.y * b.x));\n"
"}\n"
"inline float2 conjf(float2 a)\n"
"{\n"
"return (float2)(a.x, - a.y);\n"
"}\n"
"__kernel void mulAndScaleSpectrums(__global const uchar * src1ptr, int src1_step, int src1_offset,\n"
"__global const uchar * src2ptr, int src2_step, int src2_offset,\n"
"__global uchar * dstptr, int dst_step, int dst_offset,\n"
"int dst_rows, int dst_cols, int rowsPerWI)\n"
"{\n"
"int x = get_global_id(0);\n"
"int y0 = get_global_id(1) * rowsPerWI;\n"
"if (x < dst_cols)\n"
"{\n"
"int src1_index = mad24(y0, src1_step, mad24(x, (int)sizeof(float2), src1_offset));\n"
"int src2_index = mad24(y0, src2_step, mad24(x, (int)sizeof(float2), src2_offset));\n"
"int dst_index = mad24(y0, dst_step, mad24(x, (int)sizeof(float2), dst_offset));\n"
"for (int y = y0, y1 = min(dst_rows, y0 + rowsPerWI); y < y1; ++y,\n"
"src1_index += src1_step, src2_index += src2_step, dst_index += dst_step)\n"
"{\n"
"float2 src0 = *(__global const float2 *)(src1ptr + src1_index);\n"
"float2 src1 = *(__global const float2 *)(src2ptr + src2_index);\n"
"__global float2 * dst = (__global float2 *)(dstptr + dst_index);\n"
"#ifdef CONJ\n"
"float2 v = cmulf(src0, conjf(src1));\n"
"#else\n"
"float2 v = cmulf(src0, src1);\n"
"#endif\n"
"dst[0] = v;\n"
"}\n"
"}\n"
"}\n"
, "0ffb2c858f6664aa3e56efb81f025f5c", NULL};
struct cv::ocl::internal::ProgramEntry normalize_oclsrc={moduleName, "normalize",
"#ifdef DOUBLE_SUPPORT\n"
"#ifdef cl_amd_fp64\n"
"#pragma OPENCL EXTENSION cl_amd_fp64:enable\n"
"#elif defined (cl_khr_fp64)\n"
"#pragma OPENCL EXTENSION cl_khr_fp64:enable\n"
"#endif\n"
"#endif\n"
"#define noconvert\n"
"#if cn != 3\n"
"#define loadpix(addr) *(__global const srcT *)(addr)\n"
"#define storepix(val, addr) *(__global dstT *)(addr) = val\n"
"#define srcTSIZE (int)sizeof(srcT)\n"
"#define dstTSIZE (int)sizeof(dstT)\n"
"#else\n"
"#define loadpix(addr) vload3(0, (__global const srcT1 *)(addr))\n"
"#define storepix(val, addr) vstore3(val, 0, (__global dstT1 *)(addr))\n"
"#define srcTSIZE ((int)sizeof(srcT1)*3)\n"
"#define dstTSIZE ((int)sizeof(dstT1)*3)\n"
"#endif\n"
"__kernel void normalizek(__global const uchar * srcptr, int src_step, int src_offset,\n"
"__global const uchar * mask, int mask_step, int mask_offset,\n"
"__global uchar * dstptr, int dst_step, int dst_offset, int dst_rows, int dst_cols\n"
"#ifdef HAVE_SCALE\n"
", float scale\n"
"#endif\n"
"#ifdef HAVE_DELTA\n"
", float delta\n"
"#endif\n"
")\n"
"{\n"
"int x = get_global_id(0);\n"
"int y0 = get_global_id(1) * rowsPerWI;\n"
"if (x < dst_cols)\n"
"{\n"
"int src_index = mad24(y0, src_step, mad24(x, srcTSIZE, src_offset));\n"
"int mask_index = mad24(y0, mask_step, x + mask_offset);\n"
"int dst_index = mad24(y0, dst_step, mad24(x, dstTSIZE, dst_offset));\n"
"for (int y = y0, y1 = min(y0 + rowsPerWI, dst_rows); y < y1;\n"
"++y, src_index += src_step, dst_index += dst_step, mask_index += mask_step)\n"
"{\n"
"if (mask[mask_index])\n"
"{\n"
"workT value = convertToWT(loadpix(srcptr + src_index));\n"
"#ifdef HAVE_SCALE\n"
"#ifdef HAVE_DELTA\n"
"value = fma(value, (workT)(scale), (workT)(delta));\n"
"#else\n"
"value *= (workT)(scale);\n"
"#endif\n"
"#else\n"
"#ifdef HAVE_DELTA\n"
"value += (workT)(delta);\n"
"#endif\n"
"#endif\n"
"storepix(convertToDT(value), dstptr + dst_index);\n"
"}\n"
"}\n"
"}\n"
"}\n"
, "05e23451b4bf16c50a0eba9d6c5c0012", NULL};
struct cv::ocl::internal::ProgramEntry reduce_oclsrc={moduleName, "reduce",
"#ifdef DOUBLE_SUPPORT\n"
"#ifdef cl_amd_fp64\n"
"#pragma OPENCL EXTENSION cl_amd_fp64:enable\n"
"#elif defined (cl_khr_fp64)\n"
"#pragma OPENCL EXTENSION cl_khr_fp64:enable\n"
"#endif\n"
"#endif\n"
"#if defined OP_NORM_INF_MASK\n"
"#ifdef DEPTH_0\n"
"#define MIN_VAL 0\n"
"#define MAX_VAL 255\n"
"#elif defined DEPTH_1\n"
"#define MIN_VAL -128\n"
"#define MAX_VAL 127\n"
"#elif defined DEPTH_2\n"
"#define MIN_VAL 0\n"
"#define MAX_VAL 65535\n"
"#elif defined DEPTH_3\n"
"#define MIN_VAL -32768\n"
"#define MAX_VAL 32767\n"
"#elif defined DEPTH_4\n"
"#define MIN_VAL INT_MIN\n"
"#define MAX_VAL INT_MAX\n"
"#elif defined DEPTH_5\n"
"#define MIN_VAL (-FLT_MAX)\n"
"#define MAX_VAL FLT_MAX\n"
"#elif defined DEPTH_6\n"
"#define MIN_VAL (-DBL_MAX)\n"
"#define MAX_VAL DBL_MAX\n"
"#endif\n"
"#define dstT srcT\n"
"#define dstT1 srcT1\n"
"#endif\n"
"#define noconvert\n"
"#ifndef kercn\n"
"#define kercn 1\n"
"#endif\n"
"#ifdef HAVE_MASK_CONT\n"
"#define MASK_INDEX int mask_index = id + mask_offset;\n"
"#else\n"
"#define MASK_INDEX int mask_index = mad24(id / cols, mask_step, mask_offset + (id % cols))\n"
"#endif\n"
"#if cn != 3\n"
"#define loadpix(addr) *(__global const srcT *)(addr)\n"
"#define storepix(val, addr) *(__global dstT *)(addr) = val\n"
"#if kercn == 1\n"
"#define srcTSIZE (int)sizeof(srcT)\n"
"#else\n"
"#define srcTSIZE (int)sizeof(srcT1)\n"
"#endif\n"
"#define dstTSIZE (int)sizeof(dstT)\n"
"#else\n"
"#define loadpix(addr) vload3(0, (__global const srcT1 *)(addr))\n"
"#define storepix(val, addr) vstore3(val, 0, (__global dstT1 *)(addr))\n"
"#define srcTSIZE ((int)sizeof(srcT1)*3)\n"
"#define dstTSIZE ((int)sizeof(dstT1)*3)\n"
"#endif\n"
"#if ddepth <= 4\n"
"#define SUM_ABS(a) convertFromU(abs(a))\n"
"#define SUM_ABS2(a, b) convertFromU(abs_diff(a, b))\n"
"#else\n"
"#define SUM_ABS(a) fabs(a)\n"
"#define SUM_ABS2(a, b) fabs(a - b)\n"
"#endif\n"
"#ifdef HAVE_MASK\n"
"#ifdef HAVE_SRC2\n"
"#define EXTRA_PARAMS , __global const uchar * mask, int mask_step, int mask_offset, __global const uchar * src2ptr, int src2_step, int src2_offset\n"
"#else\n"
"#define EXTRA_PARAMS , __global const uchar * mask, int mask_step, int mask_offset\n"
"#endif\n"
"#else\n"
"#ifdef HAVE_SRC2\n"
"#define EXTRA_PARAMS , __global const uchar * src2ptr, int src2_step, int src2_offset\n"
"#else\n"
"#define EXTRA_PARAMS\n"
"#endif\n"
"#endif\n"
"#if defined OP_SUM || defined OP_SUM_ABS || defined OP_SUM_SQR || defined OP_DOT\n"
"#ifdef OP_DOT\n"
"#if ddepth <= 4\n"
"#define FUNC(a, b, c) a = mad24(b, c, a)\n"
"#else\n"
"#define FUNC(a, b, c) a = mad(b, c, a)\n"
"#endif\n"
"#elif defined OP_SUM\n"
"#define FUNC(a, b) a += b\n"
"#elif defined OP_SUM_ABS\n"
"#define FUNC(a, b) a += SUM_ABS(b)\n"
"#elif defined OP_SUM_SQR\n"
"#if ddepth <= 4\n"
"#define FUNC(a, b) a = mad24(b, b, a)\n"
"#else\n"
"#define FUNC(a, b) a = mad(b, b, a)\n"
"#endif\n"
"#endif\n"
"#ifdef OP_CALC2\n"
"#define DECLARE_LOCAL_MEM \\\n"
"__local dstT localmem[WGS2_ALIGNED], localmem2[WGS2_ALIGNED]\n"
"#define DEFINE_ACCUMULATOR \\\n"
"dstT accumulator = (dstT)(0), accumulator2 = (dstT)(0)\n"
"#else\n"
"#define DECLARE_LOCAL_MEM \\\n"
"__local dstT localmem[WGS2_ALIGNED]\n"
"#define DEFINE_ACCUMULATOR \\\n"
"dstT accumulator = (dstT)(0)\n"
"#endif\n"
"#ifdef HAVE_SRC2\n"
"#ifdef OP_CALC2\n"
"#define PROCESS_ELEMS \\\n"
"dstT temp = convertToDT(loadpix(srcptr + src_index)); \\\n"
"dstT temp2 = convertToDT(loadpix(src2ptr + src2_index)); \\\n"
"temp = SUM_ABS2(temp, temp2); \\\n"
"temp2 = SUM_ABS(temp2); \\\n"
"FUNC(accumulator2, temp2); \\\n"
"FUNC(accumulator, temp)\n"
"#else\n"
"#define PROCESS_ELEMS \\\n"
"dstT temp = convertToDT(loadpix(srcptr + src_index)); \\\n"
"dstT temp2 = convertToDT(loadpix(src2ptr + src2_index)); \\\n"
"temp = SUM_ABS2(temp, temp2); \\\n"
"FUNC(accumulator, temp)\n"
"#endif\n"
"#else\n"
"#define PROCESS_ELEMS \\\n"
"dstT temp = convertToDT(loadpix(srcptr + src_index)); \\\n"
"FUNC(accumulator, temp)\n"
"#endif\n"
"#ifdef HAVE_MASK\n"
"#define REDUCE_GLOBAL \\\n"
"MASK_INDEX; \\\n"
"if (mask[mask_index]) \\\n"
"{ \\\n"
"PROCESS_ELEMS; \\\n"
"}\n"
"#elif defined OP_DOT\n"
"#ifdef HAVE_SRC2_CONT\n"
"#define SRC2_INDEX int src2_index = mad24(id, srcTSIZE, src2_offset);\n"
"#else\n"
"#define SRC2_INDEX int src2_index = mad24(id / cols, src2_step, mad24(id % cols, srcTSIZE, src2_offset))\n"
"#endif\n"
"#if kercn == 1\n"
"#define REDUCE_GLOBAL \\\n"
"SRC2_INDEX; \\\n"
"dstTK temp = convertToDT(loadpix(srcptr + src_index)), temp2 = convertToDT(loadpix(src2ptr + src2_index)); \\\n"
"FUNC(accumulator, temp, temp2)\n"
"#elif kercn == 2\n"
"#define REDUCE_GLOBAL \\\n"
"SRC2_INDEX; \\\n"
"dstTK temp = convertToDT(loadpix(srcptr + src_index)), temp2 = convertToDT(loadpix(src2ptr + src2_index)); \\\n"
"FUNC(accumulator, temp.s0, temp2.s0); \\\n"
"FUNC(accumulator, temp.s1, temp2.s1)\n"
"#elif kercn == 4\n"
"#define REDUCE_GLOBAL \\\n"
"SRC2_INDEX; \\\n"
"dstTK temp = convertToDT(loadpix(srcptr + src_index)), temp2 = convertToDT(loadpix(src2ptr + src2_index)); \\\n"
"FUNC(accumulator, temp.s0, temp2.s0); \\\n"
"FUNC(accumulator, temp.s1, temp2.s1); \\\n"
"FUNC(accumulator, temp.s2, temp2.s2); \\\n"
"FUNC(accumulator, temp.s3, temp2.s3)\n"
"#elif kercn == 8\n"
"#define REDUCE_GLOBAL \\\n"
"SRC2_INDEX; \\\n"
"dstTK temp = convertToDT(loadpix(srcptr + src_index)), temp2 = convertToDT(loadpix(src2ptr + src2_index)); \\\n"
"FUNC(accumulator, temp.s0, temp2.s0); \\\n"
"FUNC(accumulator, temp.s1, temp2.s1); \\\n"
"FUNC(accumulator, temp.s2, temp2.s2); \\\n"
"FUNC(accumulator, temp.s3, temp2.s3); \\\n"
"FUNC(accumulator, temp.s4, temp2.s4); \\\n"
"FUNC(accumulator, temp.s5, temp2.s5); \\\n"
"FUNC(accumulator, temp.s6, temp2.s6); \\\n"
"FUNC(accumulator, temp.s7, temp2.s7)\n"
"#elif kercn == 16\n"
"#define REDUCE_GLOBAL \\\n"
"SRC2_INDEX; \\\n"
"dstTK temp = convertToDT(loadpix(srcptr + src_index)), temp2 = convertToDT(loadpix(src2ptr + src2_index)); \\\n"
"FUNC(accumulator, temp.s0, temp2.s0); \\\n"
"FUNC(accumulator, temp.s1, temp2.s1); \\\n"
"FUNC(accumulator, temp.s2, temp2.s2); \\\n"
"FUNC(accumulator, temp.s3, temp2.s3); \\\n"
"FUNC(accumulator, temp.s4, temp2.s4); \\\n"
"FUNC(accumulator, temp.s5, temp2.s5); \\\n"
"FUNC(accumulator, temp.s6, temp2.s6); \\\n"
"FUNC(accumulator, temp.s7, temp2.s7); \\\n"
"FUNC(accumulator, temp.s8, temp2.s8); \\\n"
"FUNC(accumulator, temp.s9, temp2.s9); \\\n"
"FUNC(accumulator, temp.sA, temp2.sA); \\\n"
"FUNC(accumulator, temp.sB, temp2.sB); \\\n"
"FUNC(accumulator, temp.sC, temp2.sC); \\\n"
"FUNC(accumulator, temp.sD, temp2.sD); \\\n"
"FUNC(accumulator, temp.sE, temp2.sE); \\\n"
"FUNC(accumulator, temp.sF, temp2.sF)\n"
"#endif\n"
"#else\n"
"#ifdef HAVE_SRC2\n"
"#ifdef OP_CALC2\n"
"#if kercn == 1\n"
"#define REDUCE_GLOBAL \\\n"
"dstTK temp = convertToDT(loadpix(srcptr + src_index)); \\\n"
"dstTK temp2 = convertToDT(loadpix(src2ptr + src2_index)); \\\n"
"temp = SUM_ABS2(temp, temp2); \\\n"
"temp2 = SUM_ABS(temp2); \\\n"
"FUNC(accumulator, temp); \\\n"
"FUNC(accumulator2, temp2)\n"
"#elif kercn == 2\n"
"#define REDUCE_GLOBAL \\\n"
"dstTK temp = convertToDT(loadpix(srcptr + src_index)); \\\n"
"dstTK temp2 = convertToDT(loadpix(src2ptr + src2_index)); \\\n"
"temp = SUM_ABS2(temp, temp2); \\\n"
"temp2 = SUM_ABS(temp2); \\\n"
"FUNC(accumulator, temp.s0); \\\n"
"FUNC(accumulator, temp.s1); \\\n"
"FUNC(accumulator2, temp2.s0); \\\n"
"FUNC(accumulator2, temp2.s1)\n"
"#elif kercn == 4\n"
"#define REDUCE_GLOBAL \\\n"
"dstTK temp = convertToDT(loadpix(srcptr + src_index)); \\\n"
"dstTK temp2 = convertToDT(loadpix(src2ptr + src2_index)); \\\n"
"temp = SUM_ABS2(temp, temp2); \\\n"
"temp2 = SUM_ABS(temp2); \\\n"
"FUNC(accumulator, temp.s0); \\\n"
"FUNC(accumulator, temp.s1); \\\n"
"FUNC(accumulator, temp.s2); \\\n"
"FUNC(accumulator, temp.s3); \\\n"
"FUNC(accumulator2, temp2.s0); \\\n"
"FUNC(accumulator2, temp2.s1); \\\n"
"FUNC(accumulator2, temp2.s2); \\\n"
"FUNC(accumulator2, temp2.s3)\n"
"#elif kercn == 8\n"
"#define REDUCE_GLOBAL \\\n"
"dstTK temp = convertToDT(loadpix(srcptr + src_index)); \\\n"
"dstTK temp2 = convertToDT(loadpix(src2ptr + src2_index)); \\\n"
"temp = SUM_ABS2(temp, temp2); \\\n"
"temp2 = SUM_ABS(temp2); \\\n"
"FUNC(accumulator, temp.s0); \\\n"
"FUNC(accumulator, temp.s1); \\\n"
"FUNC(accumulator, temp.s2); \\\n"
"FUNC(accumulator, temp.s3); \\\n"
"FUNC(accumulator, temp.s4); \\\n"
"FUNC(accumulator, temp.s5); \\\n"
"FUNC(accumulator, temp.s6); \\\n"
"FUNC(accumulator, temp.s7); \\\n"
"FUNC(accumulator2, temp2.s0); \\\n"
"FUNC(accumulator2, temp2.s1); \\\n"
"FUNC(accumulator2, temp2.s2); \\\n"
"FUNC(accumulator2, temp2.s3); \\\n"
"FUNC(accumulator2, temp2.s4); \\\n"
"FUNC(accumulator2, temp2.s5); \\\n"
"FUNC(accumulator2, temp2.s6); \\\n"
"FUNC(accumulator2, temp2.s7)\n"
"#elif kercn == 16\n"
"#define REDUCE_GLOBAL \\\n"
"dstTK temp = convertToDT(loadpix(srcptr + src_index)); \\\n"
"dstTK temp2 = convertToDT(loadpix(src2ptr + src2_index)); \\\n"
"temp = SUM_ABS2(temp, temp2); \\\n"
"temp2 = SUM_ABS(temp2); \\\n"
"FUNC(accumulator, temp.s0); \\\n"
"FUNC(accumulator, temp.s1); \\\n"
"FUNC(accumulator, temp.s2); \\\n"
"FUNC(accumulator, temp.s3); \\\n"
"FUNC(accumulator, temp.s4); \\\n"
"FUNC(accumulator, temp.s5); \\\n"
"FUNC(accumulator, temp.s6); \\\n"
"FUNC(accumulator, temp.s7); \\\n"
"FUNC(accumulator, temp.s8); \\\n"
"FUNC(accumulator, temp.s9); \\\n"
"FUNC(accumulator, temp.sA); \\\n"
"FUNC(accumulator, temp.sB); \\\n"
"FUNC(accumulator, temp.sC); \\\n"
"FUNC(accumulator, temp.sD); \\\n"
"FUNC(accumulator, temp.sE); \\\n"
"FUNC(accumulator, temp.sF); \\\n"
"FUNC(accumulator2, temp2.s0); \\\n"
"FUNC(accumulator2, temp2.s1); \\\n"
"FUNC(accumulator2, temp2.s2); \\\n"
"FUNC(accumulator2, temp2.s3); \\\n"
"FUNC(accumulator2, temp2.s4); \\\n"
"FUNC(accumulator2, temp2.s5); \\\n"
"FUNC(accumulator2, temp2.s6); \\\n"
"FUNC(accumulator2, temp2.s7); \\\n"
"FUNC(accumulator2, temp2.s8); \\\n"
"FUNC(accumulator2, temp2.s9); \\\n"
"FUNC(accumulator2, temp2.sA); \\\n"
"FUNC(accumulator2, temp2.sB); \\\n"
"FUNC(accumulator2, temp2.sC); \\\n"
"FUNC(accumulator2, temp2.sD); \\\n"
"FUNC(accumulator2, temp2.sE); \\\n"
"FUNC(accumulator2, temp2.sF)\n"
"#endif\n"
"#else\n"
"#if kercn == 1\n"
"#define REDUCE_GLOBAL \\\n"
"dstTK temp = convertToDT(loadpix(srcptr + src_index)); \\\n"
"dstTK temp2 = convertToDT(loadpix(src2ptr + src2_index)); \\\n"
"temp = SUM_ABS2(temp, temp2); \\\n"
"FUNC(accumulator, temp)\n"
"#elif kercn == 2\n"
"#define REDUCE_GLOBAL \\\n"
"dstTK temp = convertToDT(loadpix(srcptr + src_index)); \\\n"
"dstTK temp2 = convertToDT(loadpix(src2ptr + src2_index)); \\\n"
"temp = SUM_ABS2(temp, temp2); \\\n"
"FUNC(accumulator, temp.s0); \\\n"
"FUNC(accumulator, temp.s1)\n"
"#elif kercn == 4\n"
"#define REDUCE_GLOBAL \\\n"
"dstTK temp = convertToDT(loadpix(srcptr + src_index)); \\\n"
"dstTK temp2 = convertToDT(loadpix(src2ptr + src2_index)); \\\n"
"temp = SUM_ABS2(temp, temp2); \\\n"
"FUNC(accumulator, temp.s0); \\\n"
"FUNC(accumulator, temp.s1); \\\n"
"FUNC(accumulator, temp.s2); \\\n"
"FUNC(accumulator, temp.s3)\n"
"#elif kercn == 8\n"
"#define REDUCE_GLOBAL \\\n"
"dstTK temp = convertToDT(loadpix(srcptr + src_index)); \\\n"
"dstTK temp2 = convertToDT(loadpix(src2ptr + src2_index)); \\\n"
"temp = SUM_ABS2(temp, temp2); \\\n"
"FUNC(accumulator, temp.s0); \\\n"
"FUNC(accumulator, temp.s1); \\\n"
"FUNC(accumulator, temp.s2); \\\n"
"FUNC(accumulator, temp.s3); \\\n"
"FUNC(accumulator, temp.s4); \\\n"
"FUNC(accumulator, temp.s5); \\\n"
"FUNC(accumulator, temp.s6); \\\n"
"FUNC(accumulator, temp.s7)\n"
"#elif kercn == 16\n"
"#define REDUCE_GLOBAL \\\n"
"dstTK temp = convertToDT(loadpix(srcptr + src_index)); \\\n"
"dstTK temp2 = convertToDT(loadpix(src2ptr + src2_index)); \\\n"
"temp = SUM_ABS2(temp, temp2); \\\n"
"FUNC(accumulator, temp.s0); \\\n"
"FUNC(accumulator, temp.s1); \\\n"
"FUNC(accumulator, temp.s2); \\\n"
"FUNC(accumulator, temp.s3); \\\n"
"FUNC(accumulator, temp.s4); \\\n"
"FUNC(accumulator, temp.s5); \\\n"
"FUNC(accumulator, temp.s6); \\\n"
"FUNC(accumulator, temp.s7); \\\n"
"FUNC(accumulator, temp.s8); \\\n"
"FUNC(accumulator, temp.s9); \\\n"
"FUNC(accumulator, temp.sA); \\\n"
"FUNC(accumulator, temp.sB); \\\n"
"FUNC(accumulator, temp.sC); \\\n"
"FUNC(accumulator, temp.sD); \\\n"
"FUNC(accumulator, temp.sE); \\\n"
"FUNC(accumulator, temp.sF)\n"
"#endif\n"
"#endif\n"
"#else\n"
"#if kercn == 1\n"
"#define REDUCE_GLOBAL \\\n"
"dstTK temp = convertToDT(loadpix(srcptr + src_index)); \\\n"
"FUNC(accumulator, temp)\n"
"#elif kercn == 2\n"
"#define REDUCE_GLOBAL \\\n"
"dstTK temp = convertToDT(loadpix(srcptr + src_index)); \\\n"
"FUNC(accumulator, temp.s0); \\\n"
"FUNC(accumulator, temp.s1)\n"
"#elif kercn == 4\n"
"#define REDUCE_GLOBAL \\\n"
"dstTK temp = convertToDT(loadpix(srcptr + src_index)); \\\n"
"FUNC(accumulator, temp.s0); \\\n"
"FUNC(accumulator, temp.s1); \\\n"
"FUNC(accumulator, temp.s2); \\\n"
"FUNC(accumulator, temp.s3)\n"
"#elif kercn == 8\n"
"#define REDUCE_GLOBAL \\\n"
"dstTK temp = convertToDT(loadpix(srcptr + src_index)); \\\n"
"FUNC(accumulator, temp.s0); \\\n"
"FUNC(accumulator, temp.s1); \\\n"
"FUNC(accumulator, temp.s2); \\\n"
"FUNC(accumulator, temp.s3); \\\n"
"FUNC(accumulator, temp.s4); \\\n"
"FUNC(accumulator, temp.s5); \\\n"
"FUNC(accumulator, temp.s6); \\\n"
"FUNC(accumulator, temp.s7)\n"
"#elif kercn == 16\n"
"#define REDUCE_GLOBAL \\\n"
"dstTK temp = convertToDT(loadpix(srcptr + src_index)); \\\n"
"FUNC(accumulator, temp.s0); \\\n"
"FUNC(accumulator, temp.s1); \\\n"
"FUNC(accumulator, temp.s2); \\\n"
"FUNC(accumulator, temp.s3); \\\n"
"FUNC(accumulator, temp.s4); \\\n"
"FUNC(accumulator, temp.s5); \\\n"
"FUNC(accumulator, temp.s6); \\\n"
"FUNC(accumulator, temp.s7); \\\n"
"FUNC(accumulator, temp.s8); \\\n"
"FUNC(accumulator, temp.s9); \\\n"
"FUNC(accumulator, temp.sA); \\\n"
"FUNC(accumulator, temp.sB); \\\n"
"FUNC(accumulator, temp.sC); \\\n"
"FUNC(accumulator, temp.sD); \\\n"
"FUNC(accumulator, temp.sE); \\\n"
"FUNC(accumulator, temp.sF)\n"
"#endif\n"
"#endif\n"
"#endif\n"
"#ifdef OP_CALC2\n"
"#define SET_LOCAL_1 \\\n"
"localmem[lid] = accumulator; \\\n"
"localmem2[lid] = accumulator2\n"
"#define REDUCE_LOCAL_1 \\\n"
"localmem[lid - WGS2_ALIGNED] += accumulator; \\\n"
"localmem2[lid - WGS2_ALIGNED] += accumulator2\n"
"#define REDUCE_LOCAL_2 \\\n"
"localmem[lid] += localmem[lid2]; \\\n"
"localmem2[lid] += localmem2[lid2]\n"
"#define CALC_RESULT \\\n"
"storepix(localmem[0], dstptr + dstTSIZE * gid); \\\n"
"storepix(localmem2[0], dstptr + mad24(groupnum, dstTSIZE, dstTSIZE * gid))\n"
"#else\n"
"#define SET_LOCAL_1 \\\n"
"localmem[lid] = accumulator\n"
"#define REDUCE_LOCAL_1 \\\n"
"localmem[lid - WGS2_ALIGNED] += accumulator\n"
"#define REDUCE_LOCAL_2 \\\n"
"localmem[lid] += localmem[lid2]\n"
"#define CALC_RESULT \\\n"
"storepix(localmem[0], dstptr + dstTSIZE * gid)\n"
"#endif\n"
"#elif defined OP_COUNT_NON_ZERO\n"
"#define dstT int\n"
"#define DECLARE_LOCAL_MEM \\\n"
"__local dstT localmem[WGS2_ALIGNED]\n"
"#define DEFINE_ACCUMULATOR \\\n"
"dstT accumulator = (dstT)(0); \\\n"
"srcT1 zero = (srcT1)(0), one = (srcT1)(1)\n"
"#if kercn == 1\n"
"#define REDUCE_GLOBAL \\\n"
"accumulator += loadpix(srcptr + src_index) == zero ? zero : one\n"
"#elif kercn == 2\n"
"#define REDUCE_GLOBAL \\\n"
"srcT value = loadpix(srcptr + src_index); \\\n"
"accumulator += value.s0 == zero ? zero : one; \\\n"
"accumulator += value.s1 == zero ? zero : one\n"
"#elif kercn == 4\n"
"#define REDUCE_GLOBAL \\\n"
"srcT value = loadpix(srcptr + src_index); \\\n"
"accumulator += value.s0 == zero ? zero : one; \\\n"
"accumulator += value.s1 == zero ? zero : one; \\\n"
"accumulator += value.s2 == zero ? zero : one; \\\n"
"accumulator += value.s3 == zero ? zero : one\n"
"#elif kercn == 8\n"
"#define REDUCE_GLOBAL \\\n"
"srcT value = loadpix(srcptr + src_index); \\\n"
"accumulator += value.s0 == zero ? zero : one; \\\n"
"accumulator += value.s1 == zero ? zero : one; \\\n"
"accumulator += value.s2 == zero ? zero : one; \\\n"
"accumulator += value.s3 == zero ? zero : one; \\\n"
"accumulator += value.s4 == zero ? zero : one; \\\n"
"accumulator += value.s5 == zero ? zero : one; \\\n"
"accumulator += value.s6 == zero ? zero : one; \\\n"
"accumulator += value.s7 == zero ? zero : one\n"
"#elif kercn == 16\n"
"#define REDUCE_GLOBAL \\\n"
"srcT value = loadpix(srcptr + src_index); \\\n"
"accumulator += value.s0 == zero ? zero : one; \\\n"
"accumulator += value.s1 == zero ? zero : one; \\\n"
"accumulator += value.s2 == zero ? zero : one; \\\n"
"accumulator += value.s3 == zero ? zero : one; \\\n"
"accumulator += value.s4 == zero ? zero : one; \\\n"
"accumulator += value.s5 == zero ? zero : one; \\\n"
"accumulator += value.s6 == zero ? zero : one; \\\n"
"accumulator += value.s7 == zero ? zero : one; \\\n"
"accumulator += value.s8 == zero ? zero : one; \\\n"
"accumulator += value.s9 == zero ? zero : one; \\\n"
"accumulator += value.sA == zero ? zero : one; \\\n"
"accumulator += value.sB == zero ? zero : one; \\\n"
"accumulator += value.sC == zero ? zero : one; \\\n"
"accumulator += value.sD == zero ? zero : one; \\\n"
"accumulator += value.sE == zero ? zero : one; \\\n"
"accumulator += value.sF == zero ? zero : one\n"
"#endif\n"
"#define SET_LOCAL_1 \\\n"
"localmem[lid] = accumulator\n"
"#define REDUCE_LOCAL_1 \\\n"
"localmem[lid - WGS2_ALIGNED] += accumulator\n"
"#define REDUCE_LOCAL_2 \\\n"
"localmem[lid] += localmem[lid2]\n"
"#define CALC_RESULT \\\n"
"storepix(localmem[0], dstptr + dstTSIZE * gid)\n"
"#else\n"
"#error \"No operation\"\n"
"#endif\n"
"#ifdef OP_DOT\n"
"#undef EXTRA_PARAMS\n"
"#define EXTRA_PARAMS , __global uchar * src2ptr, int src2_step, int src2_offset\n"
"#endif\n"
"__kernel void reduce(__global const uchar * srcptr, int src_step, int src_offset, int cols,\n"
"int total, int groupnum, __global uchar * dstptr EXTRA_PARAMS)\n"
"{\n"
"int lid = get_local_id(0);\n"
"int gid = get_group_id(0);\n"
"int id = get_global_id(0) * kercn;\n"
"srcptr += src_offset;\n"
"#ifdef HAVE_SRC2\n"
"src2ptr += src2_offset;\n"
"#endif\n"
"DECLARE_LOCAL_MEM;\n"
"DEFINE_ACCUMULATOR;\n"
"for (int grain = groupnum * WGS * kercn; id < total; id += grain)\n"
"{\n"
"#ifdef HAVE_SRC_CONT\n"
"int src_index = id * srcTSIZE;\n"
"#else\n"
"int src_index = mad24(id / cols, src_step, mul24(id % cols, srcTSIZE));\n"
"#endif\n"
"#ifdef HAVE_SRC2\n"
"#ifdef HAVE_SRC2_CONT\n"
"int src2_index = id * srcTSIZE;\n"
"#else\n"
"int src2_index = mad24(id / cols, src2_step, mul24(id % cols, srcTSIZE));\n"
"#endif\n"
"#endif\n"
"REDUCE_GLOBAL;\n"
"}\n"
"if (lid < WGS2_ALIGNED)\n"
"{\n"
"SET_LOCAL_1;\n"
"}\n"
"barrier(CLK_LOCAL_MEM_FENCE);\n"
"if (lid >= WGS2_ALIGNED && total >= WGS2_ALIGNED)\n"
"{\n"
"REDUCE_LOCAL_1;\n"
"}\n"
"barrier(CLK_LOCAL_MEM_FENCE);\n"
"for (int lsize = WGS2_ALIGNED >> 1; lsize > 0; lsize >>= 1)\n"
"{\n"
"if (lid < lsize)\n"
"{\n"
"int lid2 = lsize + lid;\n"
"REDUCE_LOCAL_2;\n"
"}\n"
"barrier(CLK_LOCAL_MEM_FENCE);\n"
"}\n"
"if (lid == 0)\n"
"{\n"
"CALC_RESULT;\n"
"}\n"
"}\n"
, "2bd554448b0b0af7e1a1ddd57a55f5a6", NULL};
struct cv::ocl::internal::ProgramEntry reduce2_oclsrc={moduleName, "reduce2",
"#ifdef DOUBLE_SUPPORT\n"
"#ifdef cl_amd_fp64\n"
"#pragma OPENCL EXTENSION cl_amd_fp64:enable\n"
"#elif defined (cl_khr_fp64)\n"
"#pragma OPENCL EXTENSION cl_khr_fp64:enable\n"
"#endif\n"
"#endif\n"
"#if ddepth == 0\n"
"#define MIN_VAL 0\n"
"#define MAX_VAL 255\n"
"#elif ddepth == 1\n"
"#define MIN_VAL -128\n"
"#define MAX_VAL 127\n"
"#elif ddepth == 2\n"
"#define MIN_VAL 0\n"
"#define MAX_VAL 65535\n"
"#elif ddepth == 3\n"
"#define MIN_VAL -32768\n"
"#define MAX_VAL 32767\n"
"#elif ddepth == 4\n"
"#define MIN_VAL INT_MIN\n"
"#define MAX_VAL INT_MAX\n"
"#elif ddepth == 5\n"
"#define MIN_VAL (-FLT_MAX)\n"
"#define MAX_VAL FLT_MAX\n"
"#elif ddepth == 6\n"
"#define MIN_VAL (-DBL_MAX)\n"
"#define MAX_VAL DBL_MAX\n"
"#else\n"
"#error \"Unsupported depth\"\n"
"#endif\n"
"#define noconvert\n"
"#if defined OCL_CV_REDUCE_SUM || defined OCL_CV_REDUCE_AVG\n"
"#define INIT_VALUE 0\n"
"#define PROCESS_ELEM(acc, value) acc += value\n"
"#elif defined OCL_CV_REDUCE_MAX\n"
"#define INIT_VALUE MIN_VAL\n"
"#define PROCESS_ELEM(acc, value) acc = max(value, acc)\n"
"#elif defined OCL_CV_REDUCE_MIN\n"
"#define INIT_VALUE MAX_VAL\n"
"#define PROCESS_ELEM(acc, value) acc = min(value, acc)\n"
"#else\n"
"#error \"No operation is specified\"\n"
"#endif\n"
"#ifdef OP_REDUCE_PRE\n"
"__kernel void reduce_horz_opt(__global const uchar * srcptr, int src_step, int src_offset, int rows, int cols,\n"
"__global uchar * dstptr, int dst_step, int dst_offset\n"
"#ifdef OCL_CV_REDUCE_AVG\n"
", float fscale\n"
"#endif\n"
")\n"
"{\n"
"__local bufT lsmem[TILE_HEIGHT][BUF_COLS][cn];\n"
"int x = get_global_id(0);\n"
"int y = get_global_id(1);\n"
"int liy = get_local_id(1);\n"
"if ((x < BUF_COLS) && (y < rows))\n"
"{\n"
"int src_index = mad24(y, src_step, mad24(x, (int)sizeof(srcT) * cn, src_offset));\n"
"__global const srcT * src = (__global const srcT *)(srcptr + src_index);\n"
"bufT tmp[cn];\n"
"#pragma unroll\n"
"for (int c = 0; c < cn; ++c)\n"
"tmp[c] = INIT_VALUE;\n"
"int src_step_mul = BUF_COLS * cn;\n"
"for (int idx = x; idx < cols; idx += BUF_COLS, src += src_step_mul)\n"
"{\n"
"#pragma unroll\n"
"for (int c = 0; c < cn; ++c)\n"
"{\n"
"bufT value = convertToBufT(src[c]);\n"
"PROCESS_ELEM(tmp[c], value);\n"
"}\n"
"}\n"
"#pragma unroll\n"
"for (int c = 0; c < cn; ++c)\n"
"lsmem[liy][x][c] = tmp[c];\n"
"}\n"
"barrier(CLK_LOCAL_MEM_FENCE);\n"
"if ((x < BUF_COLS / 2) && (y < rows))\n"
"{\n"
"#pragma unroll\n"
"for (int c = 0; c < cn; ++c)\n"
"{\n"
"PROCESS_ELEM(lsmem[liy][x][c], lsmem[liy][x + BUF_COLS / 2][c]);\n"
"}\n"
"}\n"
"barrier(CLK_LOCAL_MEM_FENCE);\n"
"if ((x == 0) && (y < rows))\n"
"{\n"
"int dst_index = mad24(y, dst_step, dst_offset);\n"
"__global dstT * dst = (__global dstT *)(dstptr + dst_index);\n"
"bufT tmp[cn];\n"
"#pragma unroll\n"
"for (int c = 0; c < cn; ++c)\n"
"tmp[c] = INIT_VALUE;\n"
"#pragma unroll\n"
"for (int xin = 0; xin < BUF_COLS / 2; xin ++)\n"
"{\n"
"#pragma unroll\n"
"for (int c = 0; c < cn; ++c)\n"
"{\n"
"PROCESS_ELEM(tmp[c], lsmem[liy][xin][c]);\n"
"}\n"
"}\n"
"#pragma unroll\n"
"for (int c = 0; c < cn; ++c)\n"
"#ifdef OCL_CV_REDUCE_AVG\n"
"dst[c] = convertToDT(convertToWT(tmp[c]) * fscale);\n"
"#else\n"
"dst[c] = convertToDT(tmp[c]);\n"
"#endif\n"
"}\n"
"}\n"
"#else\n"
"__kernel void reduce(__global const uchar * srcptr, int src_step, int src_offset, int rows, int cols,\n"
"__global uchar * dstptr, int dst_step, int dst_offset\n"
"#ifdef OCL_CV_REDUCE_AVG\n"
", float fscale\n"
"#endif\n"
")\n"
"{\n"
"#if dim == 0\n"
"int x = get_global_id(0);\n"
"if (x < cols)\n"
"{\n"
"int src_index = mad24(x, (int)sizeof(srcT) * cn, src_offset);\n"
"int dst_index = mad24(x, (int)sizeof(dstT0) * cn, dst_offset);\n"
"__global dstT0 * dst = (__global dstT0 *)(dstptr + dst_index);\n"
"dstT tmp[cn];\n"
"#pragma unroll\n"
"for (int c = 0; c < cn; ++c)\n"
"tmp[c] = INIT_VALUE;\n"
"for (int y = 0; y < rows; ++y, src_index += src_step)\n"
"{\n"
"__global const srcT * src = (__global const srcT *)(srcptr + src_index);\n"
"#pragma unroll\n"
"for (int c = 0; c < cn; ++c)\n"
"{\n"
"dstT value = convertToDT(src[c]);\n"
"PROCESS_ELEM(tmp[c], value);\n"
"}\n"
"}\n"
"#pragma unroll\n"
"for (int c = 0; c < cn; ++c)\n"
"#ifdef OCL_CV_REDUCE_AVG\n"
"dst[c] = convertToDT0(convertToWT(tmp[c]) * fscale);\n"
"#else\n"
"dst[c] = convertToDT0(tmp[c]);\n"
"#endif\n"
"}\n"
"#elif dim == 1\n"
"int y = get_global_id(0);\n"
"if (y < rows)\n"
"{\n"
"int src_index = mad24(y, src_step, src_offset);\n"
"int dst_index = mad24(y, dst_step, dst_offset);\n"
"__global const srcT * src = (__global const srcT *)(srcptr + src_index);\n"
"__global dstT * dst = (__global dstT *)(dstptr + dst_index);\n"
"dstT tmp[cn];\n"
"#pragma unroll\n"
"for (int c = 0; c < cn; ++c)\n"
"tmp[c] = INIT_VALUE;\n"
"for (int x = 0; x < cols; ++x, src += cn)\n"
"{\n"
"#pragma unroll\n"
"for (int c = 0; c < cn; ++c)\n"
"{\n"
"dstT value = convertToDT(src[c]);\n"
"PROCESS_ELEM(tmp[c], value);\n"
"}\n"
"}\n"
"#pragma unroll\n"
"for (int c = 0; c < cn; ++c)\n"
"#ifdef OCL_CV_REDUCE_AVG\n"
"dst[c] = convertToDT0(convertToWT(tmp[c]) * fscale);\n"
"#else\n"
"dst[c] = convertToDT0(tmp[c]);\n"
"#endif\n"
"}\n"
"#else\n"
"#error \"Dims must be either 0 or 1\"\n"
"#endif\n"
"}\n"
"#endif\n"
, "675811294a4da68880f2ace25764d371", NULL};
struct cv::ocl::internal::ProgramEntry repeat_oclsrc={moduleName, "repeat",
"#if cn != 3\n"
"#define loadpix(addr) *(__global const T *)(addr)\n"
"#define storepix(val, addr) *(__global T *)(addr) = val\n"
"#define TSIZE (int)sizeof(T)\n"
"#else\n"
"#define loadpix(addr) vload3(0, (__global const T1 *)(addr))\n"
"#define storepix(val, addr) vstore3(val, 0, (__global T1 *)(addr))\n"
"#define TSIZE ((int)sizeof(T1)*3)\n"
"#endif\n"
"__kernel void repeat(__global const uchar * srcptr, int src_step, int src_offset, int src_rows, int src_cols,\n"
"__global uchar * dstptr, int dst_step, int dst_offset)\n"
"{\n"
"int x = get_global_id(0);\n"
"int y0 = get_global_id(1) * rowsPerWI;\n"
"if (x < src_cols)\n"
"{\n"
"int src_index = mad24(y0, src_step, mad24(x, (int)sizeof(T), src_offset));\n"
"int dst_index0 = mad24(y0, dst_step, mad24(x, (int)sizeof(T), dst_offset));\n"
"for (int y = y0, y1 = min(src_rows, y0 + rowsPerWI); y < y1; ++y, src_index += src_step, dst_index0 += dst_step)\n"
"{\n"
"T srcelem = loadpix(srcptr + src_index);\n"
"#pragma unroll\n"
"for (int ey = 0; ey < ny; ++ey)\n"
"{\n"
"int dst_index = mad24(ey * src_rows, dst_step, dst_index0);\n"
"#pragma unroll\n"
"for (int ex = 0; ex < nx; ++ex)\n"
"{\n"
"storepix(srcelem, dstptr + dst_index);\n"
"dst_index = mad24(src_cols, (int)sizeof(T), dst_index);\n"
"}\n"
"}\n"
"}\n"
"}\n"
"}\n"
, "d7a6b479ac9abf39f50a2d86c0b50863", NULL};
struct cv::ocl::internal::ProgramEntry set_identity_oclsrc={moduleName, "set_identity",
"#if kercn != 3\n"
"#define storepix(val, addr) *(__global T *)(addr) = val\n"
"#define TSIZE (int)sizeof(T)\n"
"#define scalar scalar_\n"
"#else\n"
"#define storepix(val, addr) vstore3(val, 0, (__global T1 *)(addr))\n"
"#define TSIZE ((int)sizeof(T1)*3)\n"
"#define scalar (T)(scalar_.x, scalar_.y, scalar_.z)\n"
"#endif\n"
"__kernel void setIdentity(__global uchar * srcptr, int src_step, int src_offset, int rows, int cols,\n"
"ST scalar_)\n"
"{\n"
"int x = get_global_id(0);\n"
"int y0 = get_global_id(1) * rowsPerWI;\n"
"if (x < cols)\n"
"{\n"
"int src_index = mad24(y0, src_step, mad24(x, TSIZE, src_offset));\n"
"#if kercn == cn\n"
"#pragma unroll\n"
"for (int y = y0, i = 0, y1 = min(rows, y0 + rowsPerWI); i < rowsPerWI; ++y, ++i, src_index += src_step)\n"
"if (y < y1)\n"
"storepix(x == y ? scalar : (T)(0), srcptr + src_index);\n"
"#elif kercn == 4 && cn == 1\n"
"if (y0 < rows)\n"
"{\n"
"storepix(x == y0 >> 2 ? (T)(scalar, 0, 0, 0) : (T)(0), srcptr + src_index);\n"
"if (++y0 < rows)\n"
"{\n"
"src_index += src_step;\n"
"storepix(x == y0 >> 2 ? (T)(0, scalar, 0, 0) : (T)(0), srcptr + src_index);\n"
"if (++y0 < rows)\n"
"{\n"
"src_index += src_step;\n"
"storepix(x == y0 >> 2 ? (T)(0, 0, scalar, 0) : (T)(0), srcptr + src_index);\n"
"if (++y0 < rows)\n"
"{\n"
"src_index += src_step;\n"
"storepix(x == y0 >> 2 ? (T)(0, 0, 0, scalar) : (T)(0), srcptr + src_index);\n"
"}\n"
"}\n"
"}\n"
"}\n"
"#else\n"
"#error \"Incorrect combination of cn && kercn\"\n"
"#endif\n"
"}\n"
"}\n"
, "75020e8c1da6cf8aece6bd5cc5b9ed4f", NULL};
struct cv::ocl::internal::ProgramEntry split_merge_oclsrc={moduleName, "split_merge",
"#ifdef OP_MERGE\n"
"#define DECLARE_SRC_PARAM(index) __global const uchar * src##index##ptr, int src##index##_step, int src##index##_offset,\n"
"#define DECLARE_INDEX(index) int src##index##_index = mad24(src##index##_step, y0, mad24(x, (int)sizeof(T) * scn##index, src##index##_offset));\n"
"#define PROCESS_ELEM(index) \\\n"
"__global const T * src##index = (__global const T *)(src##index##ptr + src##index##_index); \\\n"
"dst[index] = src##index[0]; \\\n"
"src##index##_index += src##index##_step;\n"
"__kernel void merge(DECLARE_SRC_PARAMS_N\n"
"__global uchar * dstptr, int dst_step, int dst_offset,\n"
"int rows, int cols, int rowsPerWI)\n"
"{\n"
"int x = get_global_id(0);\n"
"int y0 = get_global_id(1) * rowsPerWI;\n"
"if (x < cols)\n"
"{\n"
"DECLARE_INDEX_N\n"
"int dst_index = mad24(dst_step, y0, mad24(x, (int)sizeof(T) * cn, dst_offset));\n"
"for (int y = y0, y1 = min(rows, y0 + rowsPerWI); y < y1; ++y, dst_index += dst_step)\n"
"{\n"
"__global T * dst = (__global T *)(dstptr + dst_index);\n"
"PROCESS_ELEMS_N\n"
"}\n"
"}\n"
"}\n"
"#elif defined OP_SPLIT\n"
"#define DECLARE_DST_PARAM(index) , __global uchar * dst##index##ptr, int dst##index##_step, int dst##index##_offset\n"
"#define DECLARE_INDEX(index) int dst##index##_index = mad24(y0, dst##index##_step, mad24(x, (int)sizeof(T), dst##index##_offset));\n"
"#define PROCESS_ELEM(index) \\\n"
"__global T * dst##index = (__global T *)(dst##index##ptr + dst##index##_index); \\\n"
"dst##index[0] = src[index]; \\\n"
"dst##index##_index += dst##index##_step;\n"
"__kernel void split(__global uchar* srcptr, int src_step, int src_offset, int rows, int cols DECLARE_DST_PARAMS, int rowsPerWI)\n"
"{\n"
"int x = get_global_id(0);\n"
"int y0 = get_global_id(1) * rowsPerWI;\n"
"if (x < cols)\n"
"{\n"
"DECLARE_INDEX_N\n"
"int src_index = mad24(y0, src_step, mad24(x, cn * (int)sizeof(T), src_offset));\n"
"for (int y = y0, y1 = min(rows, y0 + rowsPerWI); y < y1; ++y, src_index += src_step)\n"
"{\n"
"__global const T * src = (__global const T *)(srcptr + src_index);\n"
"PROCESS_ELEMS_N\n"
"}\n"
"}\n"
"}\n"
"#else\n"
"#error \"No operation\"\n"
"#endif\n"
, "11e06966b3c2f2081fd02cf70337b495", NULL};
struct cv::ocl::internal::ProgramEntry transpose_oclsrc={moduleName, "transpose",
"#if cn != 3\n"
"#define loadpix(addr) *(__global const T *)(addr)\n"
"#define storepix(val, addr) *(__global T *)(addr) = val\n"
"#define TSIZE (int)sizeof(T)\n"
"#else\n"
"#define loadpix(addr) vload3(0, (__global const T1 *)(addr))\n"
"#define storepix(val, addr) vstore3(val, 0, (__global T1 *)(addr))\n"
"#define TSIZE ((int)sizeof(T1)*3)\n"
"#endif\n"
"#ifndef INPLACE\n"
"#define LDS_STEP (TILE_DIM + 1)\n"
"__kernel void transpose(__global const uchar * srcptr, int src_step, int src_offset, int src_rows, int src_cols,\n"
"__global uchar * dstptr, int dst_step, int dst_offset)\n"
"{\n"
"int gp_x = get_group_id(0), gp_y = get_group_id(1);\n"
"int gs_x = get_num_groups(0), gs_y = get_num_groups(1);\n"
"int groupId_x, groupId_y;\n"
"if (src_rows == src_cols)\n"
"{\n"
"groupId_y = gp_x;\n"
"groupId_x = (gp_x + gp_y) % gs_x;\n"
"}\n"
"else\n"
"{\n"
"int bid = mad24(gs_x, gp_y, gp_x);\n"
"groupId_y = bid % gs_y;\n"
"groupId_x = ((bid / gs_y) + groupId_y) % gs_x;\n"
"}\n"
"int lx = get_local_id(0);\n"
"int ly = get_local_id(1);\n"
"int x = mad24(groupId_x, TILE_DIM, lx);\n"
"int y = mad24(groupId_y, TILE_DIM, ly);\n"
"int x_index = mad24(groupId_y, TILE_DIM, lx);\n"
"int y_index = mad24(groupId_x, TILE_DIM, ly);\n"
"__local T tile[TILE_DIM * LDS_STEP];\n"
"if (x < src_cols && y < src_rows)\n"
"{\n"
"int index_src = mad24(y, src_step, mad24(x, TSIZE, src_offset));\n"
"#pragma unroll\n"
"for (int i = 0; i < TILE_DIM; i += BLOCK_ROWS)\n"
"if (y + i < src_rows)\n"
"{\n"
"tile[mad24(ly + i, LDS_STEP, lx)] = loadpix(srcptr + index_src);\n"
"index_src = mad24(BLOCK_ROWS, src_step, index_src);\n"
"}\n"
"}\n"
"barrier(CLK_LOCAL_MEM_FENCE);\n"
"if (x_index < src_rows && y_index < src_cols)\n"
"{\n"
"int index_dst = mad24(y_index, dst_step, mad24(x_index, TSIZE, dst_offset));\n"
"#pragma unroll\n"
"for (int i = 0; i < TILE_DIM; i += BLOCK_ROWS)\n"
"if ((y_index + i) < src_cols)\n"
"{\n"
"storepix(tile[mad24(lx, LDS_STEP, ly + i)], dstptr + index_dst);\n"
"index_dst = mad24(BLOCK_ROWS, dst_step, index_dst);\n"
"}\n"
"}\n"
"}\n"
"#else\n"
"__kernel void transpose_inplace(__global uchar * srcptr, int src_step, int src_offset, int src_rows)\n"
"{\n"
"int x = get_global_id(0);\n"
"int y = get_global_id(1) * rowsPerWI;\n"
"if (x < y + rowsPerWI)\n"
"{\n"
"int src_index = mad24(y, src_step, mad24(x, TSIZE, src_offset));\n"
"int dst_index = mad24(x, src_step, mad24(y, TSIZE, src_offset));\n"
"T tmp;\n"
"#pragma unroll\n"
"for (int i = 0; i < rowsPerWI; ++i, ++y, src_index += src_step, dst_index += TSIZE)\n"
"if (y < src_rows && x < y)\n"
"{\n"
"__global uchar * src = srcptr + src_index;\n"
"__global uchar * dst = srcptr + dst_index;\n"
"tmp = loadpix(dst);\n"
"storepix(loadpix(src), dst);\n"
"storepix(tmp, src);\n"
"}\n"
"}\n"
"}\n"
"#endif\n"
, "f938bc7c686ae7bca004809df19ef032", NULL};
}}}
#endif
| [
"[email protected]"
] | |
f3b34fc0ec5a2c9442bdbfe42ab846420025807b | 616c7d8a970a48d0e6b106c75047e2e27b6d8d22 | /msgqueue/Looper.hpp | eaca7a84ca17dea5afff9a3bdd1a5b6f58642320 | [] | no_license | snailbobo/msgqueue | 5b3ea9655d63dbd11d45dbf5d637d0a112173ede | ae3bb4aa60bda88f632073354845c5b1f501867b | refs/heads/master | 2021-03-19T16:16:44.005333 | 2017-12-07T03:45:43 | 2017-12-07T03:45:43 | 113,394,475 | 7 | 3 | null | null | null | null | UTF-8 | C++ | false | false | 293 | hpp | #ifndef _LOOPER_HPP_
#define _LOOPER_HPP_
#include "MessageQueue.hpp"
class Looper {
public:
Looper();
virtual ~Looper();
int prepare();
void loop();
private:
//Looper();
public:
MessageQueue mMsgQueue;
private:
static Looper *mpInstance;
};
#endif
| [
"[email protected]"
] | |
55b60f8ceafc29123c484b3e5783b5ba2fa77ebc | 968a4cb2feb13518940f9d125c4d6b5ae2094595 | /Utilities/Xdmf2/vtk/Testing/Cxx/XdmfTestVTKIO.cxx | 116964947f7e01f63b929c6978b6a03a84435534 | [
"LicenseRef-scancode-paraview-1.2"
] | permissive | wildmichael/ParaView3-enhancements-old | b4f2327e09cac3f81fa8c5cdb7a56bcdf960b6c1 | d889161ab8458787ec7aa3d8163904b8d54f07c5 | refs/heads/master | 2021-05-26T12:33:58.622473 | 2009-10-29T09:17:57 | 2009-10-29T09:17:57 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 7,587 | cxx | /*=========================================================================
Program: Visualization Toolkit
Module: $RCSfile: XdmfTestVTKIO.cxx,v $
Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
All rights reserved.
See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
This software is distributed WITHOUT ANY WARRANTY; without even
the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
PURPOSE. See the above copyright notice for more information.
=========================================================================*/
//Description:
//This tests vtkXdmfWriter2 and vtkXdmfReader2
//It manufactures/reads a bunch of test data objects, writes them to disk
//via the xdmfwriter, reads the files back in with the xdmfreader, and
//compares the output of the reader against the input to the reader. If
//differences are found it fails and stops immediately, leaving any failed
//files around for inspection. Otherwise it deletes the temporary files it
//creates and returns success.
#include "vtkXdmfWriter2.h"
#include "vtkCellData.h"
#include "vtkDataObject.h"
#include "vtkDataObjectGenerator.h"
#include "vtkDataSet.h"
#include "vtkDataSetWriter.h"
#include "vtkFieldData.h"
#include "vtkPointData.h"
#include "vtkDataSetReader.h"
#include "vtksys/SystemTools.hxx"
//#include "vtkTemporalFractal.h"
//#include "vtkTestUtilities.h"
#include "vtkTimeSourceExample.h"
#include "vtkXdmfReader2.h"
#define NUMTESTS 20
const char testobject[NUMTESTS][40] = {
"ID1",
"ID2",
"UF1",
"RG1",
"SG1",
"PD1",
"PD2",
"UG1",
"UG2",
"UG3",
"UG4",
"MB{}",
"MB{ID1}",
"MB{UF1}",
"MB{RG1}",
"MB{SG1}",
"MB{PD1}",
"MB{UG1}",
"MB{ ID1 UF1 RG1 SG1 PD1 UG1 }",
"HB[ (UF1)(UF1)(UF1) ]",
};
bool CleanUpGood = true;
bool DoFilesExist(const char*xdmffile, const char*hdf5file, bool deleteIfSo)
{
bool xexists = (xdmffile?vtksys::SystemTools::FileExists(xdmffile):true);
bool hexists = (hdf5file?vtksys::SystemTools::FileExists(hdf5file):true);
bool xlenOK = (xdmffile?vtksys::SystemTools::FileLength(xdmffile)!=0:true);
bool hlenOK = (hdf5file?vtksys::SystemTools::FileLength(hdf5file)!=0:true);
bool theyDo = xexists && xlenOK && hexists && hlenOK;
if (theyDo && deleteIfSo && CleanUpGood)
{
unlink(xdmffile);
unlink(hdf5file);
}
return theyDo;
}
bool DoDataObjectsDiffer(vtkDataObject *dobj1, vtkDataObject *dobj2)
{
if (strcmp(dobj1->GetClassName(), dobj2->GetClassName()))
{
cerr << "Class name test failed " << dobj1->GetClassName() << " != " << dobj2->GetClassName() << endl;
//return true; //disable for now
}
if (dobj1->GetFieldData()->GetNumberOfArrays() !=
dobj2->GetFieldData()->GetNumberOfArrays())
{
cerr << "Number of field arrays test failed" << endl;
return true;
}
if (dobj1->GetEstimatedMemorySize()!=dobj2->GetEstimatedMemorySize())
{
cerr << "Mem size test failed" << endl;
return true;
}
vtkDataSet *ds1 = vtkDataSet::SafeDownCast(dobj1);
vtkDataSet *ds2 = vtkDataSet::SafeDownCast(dobj2);
if (ds1 && ds2)
{
if ((ds1->GetNumberOfCells() != ds2->GetNumberOfCells()) ||
(ds1->GetNumberOfPoints() != ds2->GetNumberOfPoints()))
{
cerr << "Number of Cells/Points test failed" << endl;
return true;
}
double *bds1 = ds1->GetBounds();
double *bds2 = ds2->GetBounds();
if ((bds1[0]!=bds2[0]) ||
(bds1[1]!=bds2[1]) ||
(bds1[2]!=bds2[2]) ||
(bds1[3]!=bds2[3]) ||
(bds1[4]!=bds2[4]) ||
(bds1[5]!=bds2[5]))
{
cerr << "Bounds test failed" << endl;
return true;
}
if ((ds1->GetPointData()->GetNumberOfArrays() !=
ds2->GetPointData()->GetNumberOfArrays()) ||
(ds1->GetCellData()->GetNumberOfArrays() !=
ds2->GetCellData()->GetNumberOfArrays()))
{
cerr << "Number of data arrays test failed" << endl;
return true;
}
//TODO:Check array names, types, widths and ranges
}
return false;
}
bool TestXDMFConversion(vtkDataObject*input, char *prefix)
{
char xdmffile[256];
char hdf5file[256];
char vtkfile[256];
sprintf(xdmffile, "%s.xmf", prefix);
sprintf(hdf5file, "%s.h5", prefix);
sprintf(vtkfile, "%s.vtk", prefix);
vtkXdmfWriter2 *xwriter = vtkXdmfWriter2::New();
xwriter->SetLightDataLimit(10000);
xwriter->WriteAllTimeStepsOn();
xwriter->SetFileName(xdmffile);
xwriter->SetInput(input);
xwriter->Write();
xwriter->Delete();
vtkDataSet *ds = vtkDataSet::SafeDownCast(input);
if (ds)
{
vtkDataSetWriter *dsw = vtkDataSetWriter::New();
dsw->SetFileName(vtkfile);
dsw->SetInput(ds);
dsw->Write();
dsw->Delete();
}
if (!DoFilesExist(xdmffile, NULL, false))
{
cerr << "Writer did not create " << xdmffile << endl;
return true;
}
//TODO: Once it works, enable this
vtkXdmfReader2 *xreader = vtkXdmfReader2::New();
xreader->SetFileName(xdmffile);
xreader->Update();
vtkDataObject *rOutput = xreader->GetOutputDataObject(0);
bool fail = DoDataObjectsDiffer(input, rOutput);
if (!fail && CleanUpGood)
{
//test passed!
unlink(xdmffile);
unlink(hdf5file);
unlink(vtkfile);
}
xreader->Delete();
return fail;
}
int main (int ac, char **av)
{
for (int i = 1; i < ac; i++)
{
if (!strcmp(av[i], "--dont-clean"))
{
CleanUpGood = false;
}
}
bool fail = false;
//TEST SET 1
vtkDataObjectGenerator *dog = vtkDataObjectGenerator::New();
int i = 0;
while (!fail && i<NUMTESTS)
{
char filename[256];
sprintf(filename, "xdmfIOtest_%d", i);
cerr << "Test vtk object " << testobject[i] << endl;
dog->SetProgram(testobject[i]);
dog->Update();
fail = TestXDMFConversion(dog->GetOutput(), filename);
i++;
}
dog->Delete();
if (fail)
{
return VTK_ERROR;
}
//TEST SET 2
cerr << "Test temporal data" << endl;
vtkTimeSourceExample *tsrc = vtkTimeSourceExample::New();
tsrc->GrowingOn();
tsrc->SetXAmplitude(2.0);
vtkXdmfWriter2 *xwriter = vtkXdmfWriter2::New();
xwriter->SetLightDataLimit(10000);
xwriter->WriteAllTimeStepsOn();
xwriter->SetFileName("xdmfIOtest_temporal_1.xmf");
xwriter->SetInputConnection(0,tsrc->GetOutputPort(0));
xwriter->Write();
xwriter->Delete();
tsrc->Delete();
fail = !DoFilesExist("xdmfIOtest_temporal_1.xmf", NULL, true);
if (fail)
{
cerr << "Failed Temporal Test 1" << endl;
return VTK_ERROR;
}
#if 0
if (!vtkTestUtilities::GetDataRoot(ac,av))
{
cerr << "NO DATA ROOT" << endl;
return 0;
}
//TEST SET 3
char* fname =
vtkTestUtilities::ExpandDataFileName(
ac, av, "Data/RectGrid2.vtk");
if (DoFilesExist(fname, NULL, false))
{
vtkDataSetReader *dsr = vtkDataSetReader::New();
dsr->SetFileName(fname);
dsr->Update();
fail = TestXDMFConversion(dsr->GetOutput(), "xdmfIOtest_DSR_1");
dsr->Delete();
delete[] fname;
if (fail)
{
cerr << "Failed DataSetReader Test 1" << endl;
return VTK_ERROR;
}
dsr = vtkDataSetReader::New();
fname =
vtkTestUtilities::ExpandDataFileName(
ac, av, "Data/uGridEx.vtk");
dsr->SetFileName(fname);
dsr->Update();
fail = TestXDMFConversion(dsr->GetOutput(), "xdmfIOtest_DSR_2");
dsr->Delete();
delete[] fname;
if (fail)
{
cerr << "Failed DataSetReader Test 2" << endl;
return VTK_ERROR;
}
}
else
{
delete[] fname;
}
#endif
//ETC.
return 0;
}
| [
"dave.demarle"
] | dave.demarle |
e47ebcf9bbac356833a04314d25cb9843bc00246 | e286c6903d89be12d0194fcefb1c72850c263e16 | /src/sparse_spectral_approximation/txssa.cpp | 6946c8189c7d3aef9aabf1177b4665e1c55b54cf | [
"BSD-2-Clause"
] | permissive | cjhurani/txssa | f21bff03d17b9b61c247d2e0c0d17a103a123067 | 473bb4ec650cb7164d80fc531ac38a6c28226dd8 | refs/heads/master | 2020-05-16T03:10:47.240674 | 2015-03-18T04:01:45 | 2015-03-18T04:01:45 | 32,197,551 | 2 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 54,121 | cpp | /*
TxSSA: Tech-X Sparse Spectral Approximation
Copyright (C) 2012 Tech-X Corporation, 5621 Arapahoe Ave, Boulder CO 80303
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are
met:
1. Redistributions of source code must retain the above copyright notice,
this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
3. Neither the name of the Tech-X Corporation nor the names of its
contributors may be used to endorse or promote products derived from
this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
/*
Authors:
1. Chetan Jhurani ([email protected], [email protected])
For more information and relevant publications, visit
http://www.ices.utexas.edu/~chetan/
2. Travis M. Austin ([email protected])
Contact address:
Tech-X Corporation
5621 Arapahoe Ave
Boulder, CO 80303
http://www.txcorp.com
*/
// -----------------------------------------------------------------------------
#include "txssa.h"
#include "sparse_spectral_approximation/ssa_matrix_type.h"
#include "sparse_spectral_approximation/ssa_matrix_type_pinv_transpose.h"
#include "sparse_spectral_approximation/sparse_spectral_minimization.h"
#include "sparse_spectral_approximation/sparse_spectral_misfit_lhs_matrices.h"
#include "sparse_spectral_approximation/sparse_spectral_binning.h"
#include "sparse_vectors/sparse_vectors.h"
#include "p_norm_sparsity_matrix/p_norm_sparsity_dense_matrix.h"
#include "dense_algorithms/dense_matrix_utils.h"
#include "dense_vectors/dense_vectors.h"
#include "math/precision_traits.h"
#include "internal_api_error/internal_api_error.h"
#include <algorithm> // std::copy
#include <vector>
#include <stdexcept>
#include <complex>
#include <cassert>
#include <new>
// -----------------------------------------------------------------------------
#ifdef _MSC_VER
#pragma warning( disable : 4514 ) // unreferenced inline function has been removed
#pragma warning( disable : 4710 ) // function not inlined
#endif
// -----------------------------------------------------------------------------
const unsigned int ssa_impl_version = 0;
// -----------------------------------------------------------------------------
namespace
{
// -----------------------------------------------------------------------------
template<typename T>
void delete_catch(T* ptr, const char* func_name)
{
try
{
delete ptr;
}
catch(...)
{
assert(false);
internal_api_error_set_last(
std::string(func_name) + ": Exception in deleting a pointer.");
}
}
// -----------------------------------------------------------------------------
template<typename index_type, typename value_type>
bool ssa_matrix_type_compute_AAT_from_ATA(
index_type size,
const value_type* ATA_col_values,
index_type ATA_col_leading_dim,
value_type* AAT_col_values,
index_type AAT_col_leading_dim,
ssa_matrix_type type)
{
bool success = false;
// This is the only one implemented/needed now.
if(type == ssa_matrix_type_complex_symmetric)
{
success = dense_matrix_utils_complex_sym_compute_AAT_from_ATA(
size,
ATA_col_values, ATA_col_leading_dim,
AAT_col_values, AAT_col_leading_dim);
}
if(!success)
{
assert(false);
internal_api_error_set_last(
"ssa_matrix_type_compute_AAT_from_ATA: Error");
}
return success;
}
// -----------------------------------------------------------------------------
template<typename index_type, typename value_type>
void ssa_B2TB2_chooser(
const dense_vectors<index_type, value_type>& B1TB1,
const dense_vectors<index_type, value_type>& B2TB2,
ssa_matrix_type matrix_type,
bool is_binned,
const value_type*& tmp_B2TB2_col_values,
typename precision_traits<value_type>::scalar& mult_factor)
{
// The reason we compute B1B1T and then compute B2TB2 from it instead of
// the other way around (this is when such the two matrices are related),
// is that on some Intel MKL versions X'*X is slightly faster than X*X',
// say, 5-10%.
// hermitian implies normal, so only 6 combinations.
// hermitian binned normal b2 mult_factor
// 0 0 0 pass b2 2
// 0 0 1 pass b1 2
// 0 1 0 pass b2 2
// 0 1 1 pass b1 2
// 1 0 1 pass b1 2
// 1 1 1 pass 0 1
tmp_B2TB2_col_values = 0;
const int is_hermitian = ssa_matrix_type_is_hermitian(matrix_type);
const int is_normal = ssa_matrix_type_is_normal(matrix_type);
if(is_normal)
{
if(!is_hermitian || !is_binned)
{
tmp_B2TB2_col_values = B1TB1.vec_values();
}
}
else
{
tmp_B2TB2_col_values = B2TB2.vec_values();
}
typedef typename precision_traits<value_type>::scalar scalar_type;
mult_factor = tmp_B2TB2_col_values ? scalar_type(2) : scalar_type(1);
}
// -----------------------------------------------------------------------------
// User-given parameters for computing L_p norm based pattern.
template
<
typename index_type,
typename offset_type,
typename value_type
>
bool ssa_lpn_internal(
index_type num_rows,
index_type num_cols,
const value_type* col_values,
index_type col_leading_dim,
typename precision_traits<value_type>::scalar sparsity_ratio,
typename precision_traits<value_type>::scalar sparsity_norm_p,
offset_type max_num_bins,
bool impose_null_spaces,
enum ssa_matrix_type matrix_type,
ssa_csr<index_type, offset_type, value_type>& out_matrix)
{
ssa_error_clear();
const int is_abs_sym = ssa_matrix_type_is_abs_sym(matrix_type);
bool success =
ssa_matrix_type_undefined < matrix_type &&
matrix_type < ssa_matrix_type_num_types &&
(num_rows == num_cols || !is_abs_sym) &&
col_values;
if(!success)
{
assert(false);
internal_api_error_set_last(
"ssa_lpn_internal: Unacceptable input argument(s).");
return false;
}
dense_vectors<index_type, value_type> pinv_AT, left_null_space, right_null_space;
dense_vectors<index_type, value_type>* left_null_space_ptr = 0;
dense_vectors<index_type, value_type>* right_null_space_ptr = 0;
if(impose_null_spaces)
{
left_null_space_ptr = &left_null_space;
right_null_space_ptr = &right_null_space;
}
success =
pinv_AT.allocate(
num_cols, num_rows)
&&
dense_vectors_utils_copy(
num_cols, num_rows,
col_values, col_leading_dim,
pinv_AT.vec_values(), pinv_AT.leading_dimension())
&&
ssa_matrix_type_pinv_transpose(
num_rows, num_cols,
pinv_AT.vec_values(), pinv_AT.leading_dimension(),
matrix_type,
left_null_space_ptr, right_null_space_ptr);
if(success)
{
// ISSUE: Ideally, we should be using an equivalent of the near_zero_row_col
// function written in the MATLAB code to compute min_num_nnz_per_row
// and min_num_nnz_per_col. We skip that step.
const index_type min_num_nnz_per_row = right_null_space.num_vecs();
const index_type min_num_nnz_per_col = left_null_space.num_vecs();
std::vector< std::vector<index_type> > row_oriented_sparse_pat;
if(is_abs_sym)
{
const int left_right_nullity_equal = ssa_matrix_type_is_left_right_nullity_equal(matrix_type);
if(left_right_nullity_equal && min_num_nnz_per_row != min_num_nnz_per_col)
{
assert(false);
internal_api_error_set_last(
"ssa_lpn_internal: Left and right nullity should be equal"
" because of matrix type, but not computed to be equal.");
return false;
}
success = p_norm_sparsity_dense_matrix_abs_sym(
sparsity_ratio, sparsity_norm_p,
min_num_nnz_per_row,
num_rows,
col_values, col_leading_dim,
row_oriented_sparse_pat);
}
else
{
success = p_norm_sparsity_dense_matrix_col_oriented(
sparsity_ratio, sparsity_norm_p,
min_num_nnz_per_row, min_num_nnz_per_col,
num_rows, num_cols,
col_values, col_leading_dim,
row_oriented_sparse_pat);
}
if(success)
{
std::vector<index_type> size_per_row(num_rows);
for(index_type row = 0; row < num_rows; ++row)
size_per_row[row] = index_type(row_oriented_sparse_pat[row].size());
sparse_vectors<index_type, offset_type, value_type>* out_mat_ptr =
new (std::nothrow) sparse_vectors<index_type, offset_type, value_type>();
if(!out_mat_ptr)
{
assert(false);
internal_api_error_set_last(
"ssa_lpn_internal: Error in allocating matrix.");
return false;
}
if(num_rows > 0)
{
success = out_mat_ptr->allocate(num_rows, num_cols, &size_per_row.front());
}
else
{
index_type tmp_size_per_row = 0;
success = out_mat_ptr->allocate(num_rows, num_cols, &tmp_size_per_row);
}
if(success)
{
for(index_type row = 0; row < num_rows; ++row)
std::copy(
row_oriented_sparse_pat[row].begin(),
row_oriented_sparse_pat[row].end(),
out_mat_ptr->vec_ids_begin(row));
success =
ssa_internal(
num_rows, num_cols,
col_values, col_leading_dim,
out_mat_ptr->vec_offsets(),
out_mat_ptr->vec_ids(),
max_num_bins,
impose_null_spaces,
pinv_AT, left_null_space, right_null_space,
matrix_type,
out_mat_ptr->vec_values());
if(success)
{
out_matrix.row_offsets = out_mat_ptr->vec_offsets();
out_matrix.column_ids = out_mat_ptr->vec_ids();
out_matrix.values = out_mat_ptr->vec_values();
out_matrix.reserved = out_mat_ptr;
}
}
}
}
if(!success)
{
assert(false);
internal_api_error_set_last(
"ssa_lpn_internal: Error");
}
return success;
}
// -----------------------------------------------------------------------------
template
<
typename index_type,
typename offset_type,
typename value_type
>
bool ssa_ids_internal(
index_type num_rows,
index_type num_cols,
const value_type* col_values,
index_type col_leading_dim,
typename precision_traits<value_type>::scalar sparsity_ratio,
typename precision_traits<value_type>::scalar sparsity_norm_p,
index_type min_num_nnz_per_row,
index_type min_num_nnz_per_col,
enum ssa_matrix_type matrix_type,
ssa_csr<index_type, offset_type, value_type>& out_matrix)
{
ssa_error_clear();
const int is_abs_sym = ssa_matrix_type_is_abs_sym(matrix_type);
bool success =
ssa_matrix_type_undefined < matrix_type &&
matrix_type < ssa_matrix_type_num_types &&
(num_rows == num_cols || !is_abs_sym) &&
(min_num_nnz_per_row == min_num_nnz_per_col || !is_abs_sym) &&
col_values;
if(!success)
{
assert(false);
internal_api_error_set_last(
"ssa_ids_internal: Unacceptable input argument(s).");
return false;
}
std::vector< std::vector<index_type> > row_oriented_sparse_pat;
if(is_abs_sym)
{
success = p_norm_sparsity_dense_matrix_abs_sym(
sparsity_ratio, sparsity_norm_p,
min_num_nnz_per_row,
num_rows,
col_values, col_leading_dim,
row_oriented_sparse_pat);
}
else
{
success = p_norm_sparsity_dense_matrix_col_oriented(
sparsity_ratio, sparsity_norm_p,
min_num_nnz_per_row, min_num_nnz_per_col,
num_rows, num_cols,
col_values, col_leading_dim,
row_oriented_sparse_pat);
}
if(success)
{
std::vector<index_type> size_per_row(num_rows);
for(index_type row = 0; row < num_rows; ++row)
size_per_row[row] = index_type(row_oriented_sparse_pat[row].size());
sparse_vectors<index_type, offset_type, value_type>* out_mat_ptr =
new (std::nothrow) sparse_vectors<index_type, offset_type, value_type>();
if(!out_mat_ptr)
{
assert(false);
internal_api_error_set_last(
"ssa_ids_internal: Error in allocating matrix.");
return false;
}
success = out_mat_ptr->allocate(num_rows, num_cols, &size_per_row.front());
if(success)
{
for(index_type row = 0; row < num_rows; ++row)
std::copy(
row_oriented_sparse_pat[row].begin(),
row_oriented_sparse_pat[row].end(),
out_mat_ptr->vec_ids_begin(row));
out_matrix.row_offsets = out_mat_ptr->vec_offsets();
out_matrix.column_ids = out_mat_ptr->vec_ids();
out_matrix.values = out_mat_ptr->vec_values();
out_matrix.reserved = out_mat_ptr;
}
}
if(!success)
{
assert(false);
internal_api_error_set_last(
"ssa_ids_internal: Error");
}
return success;
}
// -----------------------------------------------------------------------------
// For real matrices
template
<
typename index_type,
typename offset_type,
typename value_type
>
bool ssa_internal(
index_type num_rows,
index_type num_cols,
const value_type* col_values, // num_rows x num_cols
index_type col_leading_dim,
const offset_type* row_offsets, // num_rows + 1
const index_type* column_ids, // row_offsets[num_rows]
offset_type max_num_bins,
bool impose_null_spaces,
const dense_vectors<index_type, value_type>& pinv_AT,
const dense_vectors<index_type, value_type>& left_null_space,
const dense_vectors<index_type, value_type>& right_null_space,
ssa_matrix_type matrix_type,
value_type* out_row_values) // row_offsets[num_rows]
{
const int is_square = (num_rows == num_cols);
const int is_hermitian = ssa_matrix_type_is_hermitian(matrix_type);
const int is_normal = ssa_matrix_type_is_normal(matrix_type);
bool success =
!(
is_hermitian ||
is_normal
) ||
is_square;
if(!success)
{
assert(false);
internal_api_error_set_last(
"ssa_internal: Unacceptable input argument(s) in real version.");
return false;
}
std::vector<offset_type> row_bin_ids;
try
{
row_bin_ids.resize(row_offsets[num_rows]);
}
catch(const std::exception& exc)
{
assert(false);
internal_api_error_set_last(
(std::string("ssa_internal: Exception in the real version. ") + exc.what()));
return false;
}
dense_vectors<index_type, value_type> B1TB1, B2TB2;
offset_type actual_num_bins;
dense_vectors<offset_type, sparse_vectors_ids<index_type, offset_type> >
row_split_pattern, col_split_pattern;
success =
sparse_spectral_binning_row(
num_rows, num_cols,
col_values, col_leading_dim,
row_offsets, column_ids,
max_num_bins, actual_num_bins,
row_split_pattern,
row_bin_ids.size() ? &row_bin_ids.front() : 0)
&&
// If hermitian, don't have to compute col_split_pattern
(is_hermitian ? true : sparse_spectral_binning_to_col(
num_rows, num_cols,
row_offsets, column_ids,
row_bin_ids.size() ? &row_bin_ids.front() : 0,
actual_num_bins,
col_split_pattern))
&&
B1TB1.allocate(
num_cols, num_cols)
&&
// If normal, don't have to allocate or compute B2TB2
(is_normal ? true : B2TB2.allocate(
num_rows, num_rows))
&&
sparse_spectral_misfit_lhs_matrices(
num_rows,
num_cols,
pinv_AT.vec_values(), pinv_AT.leading_dimension(),
B2TB2.vec_values(), B2TB2.leading_dimension(),
B1TB1.vec_values(), B1TB1.leading_dimension());
if(success)
{
const value_type* tmp_B2TB2_col_values = 0;
value_type mult_factor;
const bool is_binned = max_num_bins != 0;
ssa_B2TB2_chooser<index_type, value_type>(
B1TB1,
B2TB2,
matrix_type,
is_binned,
tmp_B2TB2_col_values,
mult_factor);
success = sparse_spectral_minimization(
num_rows, num_cols,
row_offsets, column_ids,
actual_num_bins,
row_bin_ids.size() ? &row_bin_ids.front() : 0,
row_split_pattern.vec_values(),
// If hermitian, reuse row_split_pattern as col_split_pattern
is_hermitian ? row_split_pattern.vec_values() : col_split_pattern.vec_values(),
impose_null_spaces,
tmp_B2TB2_col_values, num_rows,
B1TB1.vec_values(), B1TB1.leading_dimension(),
pinv_AT.vec_values(), pinv_AT.leading_dimension(),
left_null_space,
right_null_space,
out_row_values,
mult_factor);
}
if(!success)
{
assert(false);
internal_api_error_set_last(
"ssa_internal: Error in real version.");
}
return success;
}
// -----------------------------------------------------------------------------
// For complex matrices
template
<
typename index_type,
typename offset_type,
typename scalar_type
>
bool ssa_internal(
index_type num_rows,
index_type num_cols,
const std::complex<scalar_type>* col_values, // num_rows x num_cols
index_type col_leading_dim,
const offset_type* row_offsets, // num_rows + 1
const index_type* column_ids, // row_offsets[num_rows]
offset_type max_num_bins,
bool impose_null_spaces,
const dense_vectors<index_type, std::complex<scalar_type> >& pinv_AT,
const dense_vectors<index_type, std::complex<scalar_type> >& left_null_space,
const dense_vectors<index_type, std::complex<scalar_type> >& right_null_space,
ssa_matrix_type matrix_type,
std::complex<scalar_type>* out_row_values) // row_offsets[num_rows]
{
const int is_square = (num_rows == num_cols);
const int is_hermitian = ssa_matrix_type_is_hermitian(matrix_type);
const int is_normal = ssa_matrix_type_is_normal(matrix_type);
const int is_real_part_symmetric = ssa_matrix_type_is_real_part_symmetric(matrix_type);
const int is_imag_part_symmetric = ssa_matrix_type_is_imag_part_symmetric(matrix_type);
const int is_AAT_computable_from_ATA = ssa_matrix_type_is_AAT_computable_from_ATA(matrix_type);
bool success =
!(
is_hermitian ||
is_normal ||
is_real_part_symmetric ||
is_imag_part_symmetric ||
is_AAT_computable_from_ATA
) ||
is_square;
if(!success)
{
assert(false);
internal_api_error_set_last(
"ssa_internal: Unacceptable input argument(s) in complex version.");
return false;
}
std::vector<offset_type> real_row_bin_ids, imag_row_bin_ids;
try
{
real_row_bin_ids.resize(row_offsets[num_rows]);
imag_row_bin_ids.resize(row_offsets[num_rows]);
}
catch(const std::exception& exc)
{
assert(false);
internal_api_error_set_last(
(std::string("ssa_internal: Exception in complex version. ") + exc.what()));
return false;
}
dense_vectors<index_type, std::complex<scalar_type> > B1TB1, B2TB2;
offset_type real_actual_num_bins, imag_actual_num_bins;
dense_vectors<offset_type, sparse_vectors_ids<index_type, offset_type> >
real_row_split_pattern, real_col_split_pattern,
imag_row_split_pattern, imag_col_split_pattern;
success =
sparse_spectral_binning_row(
num_rows, num_cols,
col_values, col_leading_dim,
row_offsets, column_ids,
max_num_bins,
real_actual_num_bins, imag_actual_num_bins,
real_row_split_pattern, imag_row_split_pattern,
real_row_bin_ids.size() ? &real_row_bin_ids.front() : 0,
imag_row_bin_ids.size() ? &imag_row_bin_ids.front() : 0)
&&
// If real part hermitian, don't have to compute real_col_split_pattern
(is_real_part_symmetric ? true : sparse_spectral_binning_to_col(
num_rows, num_cols,
row_offsets, column_ids,
real_row_bin_ids.size() ? &real_row_bin_ids.front() : 0,
real_actual_num_bins,
real_col_split_pattern))
&&
// If imag part hermitian, don't have to compute imag_col_split_pattern
(is_imag_part_symmetric ? true : sparse_spectral_binning_to_col(
num_rows, num_cols,
row_offsets, column_ids,
imag_row_bin_ids.size() ? &imag_row_bin_ids.front() : 0,
imag_actual_num_bins,
imag_col_split_pattern))
&&
B1TB1.allocate(
num_cols, num_cols)
&&
// If normal, don't have to allocate or compute B2TB2
(is_normal ? true : B2TB2.allocate(
num_rows, num_rows));
if(success)
{
if(is_AAT_computable_from_ATA)
{
success =
sparse_spectral_misfit_lhs_matrices(
num_rows,
num_cols,
pinv_AT.vec_values(), pinv_AT.leading_dimension(),
reinterpret_cast<std::complex<scalar_type>*>(0), num_rows,
B1TB1.vec_values(), B1TB1.leading_dimension())
&&
ssa_matrix_type_compute_AAT_from_ATA(
num_rows,
B1TB1.vec_values(), B1TB1.leading_dimension(),
B2TB2.vec_values(), B2TB2.leading_dimension(),
matrix_type);
}
else
{
success = sparse_spectral_misfit_lhs_matrices(
num_rows,
num_cols,
pinv_AT.vec_values(), pinv_AT.leading_dimension(),
B2TB2.vec_values(), B2TB2.leading_dimension(),
B1TB1.vec_values(), B1TB1.leading_dimension());
}
if(success)
{
const std::complex<scalar_type>* tmp_B2TB2_col_values = 0;
scalar_type mult_factor;
const bool is_binned = max_num_bins != 0;
ssa_B2TB2_chooser<index_type, std::complex<scalar_type> >(
B1TB1,
B2TB2,
matrix_type,
is_binned,
tmp_B2TB2_col_values,
mult_factor);
success = sparse_spectral_minimization(
num_rows, num_cols,
row_offsets, column_ids,
real_actual_num_bins, imag_actual_num_bins,
real_row_bin_ids.size() ? &real_row_bin_ids.front() : 0,
imag_row_bin_ids.size() ? &imag_row_bin_ids.front() : 0,
real_row_split_pattern.vec_values(), imag_row_split_pattern.vec_values(),
is_real_part_symmetric ? real_row_split_pattern.vec_values() : real_col_split_pattern.vec_values(),
is_imag_part_symmetric ? imag_row_split_pattern.vec_values() : imag_col_split_pattern.vec_values(),
impose_null_spaces,
tmp_B2TB2_col_values, num_rows,
B1TB1.vec_values(), B1TB1.leading_dimension(),
pinv_AT.vec_values(), pinv_AT.leading_dimension(),
left_null_space,
right_null_space,
out_row_values,
mult_factor);
}
}
if(!success)
{
assert(false);
internal_api_error_set_last(
"ssa_internal: Error in complex version.");
}
return success;
}
// -----------------------------------------------------------------------------
} // namespace
// -----------------------------------------------------------------------------
template
<
typename index_type,
typename offset_type,
typename value_type
>
ssa_csr<index_type, offset_type, value_type>::ssa_csr()
:
row_offsets(0),
column_ids(0),
values(0),
reserved(0)
{
}
template
<
typename index_type,
typename offset_type,
typename value_type
>
ssa_csr<index_type, offset_type, value_type>::~ssa_csr()
{
delete_catch(reinterpret_cast
<const sparse_vectors<index_type, offset_type, value_type>*>(
reserved), "ssa_csr::~ssa_csr()");
reserved = 0;
}
// -----------------------------------------------------------------------------
// User-given pattern.
template
<
typename index_type,
typename offset_type,
typename value_type
>
int ssa_pat(
index_type num_rows,
index_type num_cols,
const value_type* col_values,
index_type col_leading_dim,
const offset_type* row_offsets,
const index_type* column_ids,
offset_type max_num_bins,
bool impose_null_spaces,
enum ssa_matrix_type matrix_type,
value_type* out_row_values)
{
ssa_error_clear();
bool success =
ssa_matrix_type_undefined < matrix_type &&
matrix_type < ssa_matrix_type_num_types &&
(num_rows == num_cols || !ssa_matrix_type_is_abs_sym(matrix_type)) &&
col_values &&
row_offsets &&
column_ids &&
out_row_values;
if(!success)
{
assert(false);
internal_api_error_set_last(
"ssa_pat: Unacceptable input argument(s).");
return false;
}
dense_vectors<index_type, value_type>
pinv_AT, left_null_space, right_null_space;
dense_vectors<index_type, value_type>* left_null_space_ptr = 0;
dense_vectors<index_type, value_type>* right_null_space_ptr = 0;
if(impose_null_spaces)
{
left_null_space_ptr = &left_null_space;
right_null_space_ptr = &right_null_space;
}
success =
pinv_AT.allocate(
num_cols, num_rows)
&&
dense_vectors_utils_copy(
num_cols, num_rows,
col_values, col_leading_dim,
pinv_AT.vec_values(), pinv_AT.leading_dimension())
&&
ssa_matrix_type_pinv_transpose(
num_rows, num_cols,
pinv_AT.vec_values(), pinv_AT.leading_dimension(),
matrix_type,
left_null_space_ptr, right_null_space_ptr)
&&
ssa_internal(
num_rows, num_cols,
col_values, col_leading_dim,
row_offsets, column_ids,
max_num_bins,
impose_null_spaces,
pinv_AT, left_null_space, right_null_space,
matrix_type,
out_row_values);
if(!success)
{
assert(false);
internal_api_error_set_last(
"ssa_pat: Error.");
}
return success ? 0 : 1;
}
// -----------------------------------------------------------------------------
template
<
typename index_type,
typename offset_type,
typename value_type
>
int ssa_lpn(
index_type num_rows,
index_type num_cols,
const value_type* col_values,
index_type col_leading_dim,
value_type sparsity_ratio,
value_type sparsity_norm_p,
offset_type max_num_bins,
bool impose_null_spaces,
enum ssa_matrix_type matrix_type,
ssa_csr<index_type, offset_type, value_type>& out_matrix)
{
bool success = ssa_lpn_internal<index_type, offset_type, value_type>(
num_rows, num_cols,
col_values, col_leading_dim,
sparsity_ratio, sparsity_norm_p,
max_num_bins,
impose_null_spaces,
matrix_type,
out_matrix);
if(!success)
{
assert(false);
internal_api_error_set_last(
"ssa_lpn: Error in real version");
}
return success ? 0 : 1;
}
template
<
typename index_type,
typename offset_type,
typename scalar_type
>
int ssa_lpn(
index_type num_rows,
index_type num_cols,
const std::complex<scalar_type>* col_values,
index_type col_leading_dim,
scalar_type sparsity_ratio,
scalar_type sparsity_norm_p,
offset_type max_num_bins,
bool impose_null_spaces,
enum ssa_matrix_type matrix_type,
ssa_csr<index_type, offset_type, std::complex<scalar_type> >& out_matrix)
{
bool success = ssa_lpn_internal<index_type, offset_type, std::complex<scalar_type> >(
num_rows, num_cols,
col_values, col_leading_dim,
sparsity_ratio, sparsity_norm_p,
max_num_bins,
impose_null_spaces,
matrix_type,
out_matrix);
if(!success)
{
assert(false);
internal_api_error_set_last(
"ssa_lpn: Error in complex version");
}
return success ? 0 : 1;
}
// -----------------------------------------------------------------------------
template
<
typename index_type,
typename offset_type,
typename value_type
>
int ssa_ids(
index_type num_rows,
index_type num_cols,
const value_type* col_values,
index_type col_leading_dim,
value_type sparsity_ratio,
value_type sparsity_norm_p,
index_type min_num_nnz_per_row,
index_type min_num_nnz_per_col,
enum ssa_matrix_type matrix_type,
ssa_csr<index_type, offset_type, value_type>& out_matrix)
{
bool success = ssa_ids_internal<index_type, offset_type, value_type>(
num_rows, num_cols,
col_values, col_leading_dim,
sparsity_ratio, sparsity_norm_p,
min_num_nnz_per_row, min_num_nnz_per_col,
matrix_type,
out_matrix);
if(!success)
{
assert(false);
internal_api_error_set_last(
"ssa_ids: Error in real version");
}
return success ? 0 : 1;
}
template
<
typename index_type,
typename offset_type,
typename scalar_type
>
int ssa_ids(
index_type num_rows,
index_type num_cols,
const std::complex<scalar_type>* col_values,
index_type col_leading_dim,
scalar_type sparsity_ratio,
scalar_type sparsity_norm_p,
index_type min_num_nnz_per_row,
index_type min_num_nnz_per_col,
enum ssa_matrix_type matrix_type,
ssa_csr<index_type, offset_type, std::complex<scalar_type> >& out_matrix)
{
bool success = ssa_ids_internal<index_type, offset_type, std::complex<scalar_type> >(
num_rows, num_cols,
col_values, col_leading_dim,
sparsity_ratio, sparsity_norm_p,
min_num_nnz_per_row, min_num_nnz_per_col,
matrix_type,
out_matrix);
if(!success)
{
assert(false);
internal_api_error_set_last(
"ssa_ids: Error in complex version");
}
return success ? 0 : 1;
}
// -----------------------------------------------------------------------------
int ssa_error_size()
{
return internal_api_error_size();
}
int ssa_error_string(int i, const char** ptr_to_error_string)
{
return internal_api_error_string(i, ptr_to_error_string);
}
int ssa_error_clear()
{
return internal_api_error_clear();
}
// -----------------------------------------------------------------------------
/* User-given pattern */
int ssa_d_pat(
int num_rows,
int num_cols,
const double* col_values,
int col_leading_dim,
const int* row_offsets,
const int* column_ids,
int max_num_bins,
int impose_null_spaces,
enum ssa_matrix_type matrix_type,
double* out_row_values)
{
int ret = ssa_pat(
num_rows, num_cols,
col_values, col_leading_dim,
row_offsets, column_ids,
max_num_bins,
impose_null_spaces == 0 ? false : true,
matrix_type,
out_row_values);
return ret;
}
/* User-given parameters for computing L_p norm based pattern. */
int ssa_d_lpn(
int num_rows,
int num_cols,
const double* col_values,
int col_leading_dim,
double sparsity_ratio,
double sparsity_norm_p,
int max_num_bins,
int impose_null_spaces,
enum ssa_matrix_type matrix_type,
struct ssa_d_csr* out_matrix)
{
ssa_csr<int, int, double>* csr = new (std::nothrow) ssa_csr<int, int, double>;
if(!csr)
{
assert(false);
internal_api_error_set_last("ssa_d_lpn: Memory allocation failed.");
return 1;
}
int ret = ssa_lpn(
num_rows, num_cols,
col_values, col_leading_dim,
sparsity_ratio, sparsity_norm_p,
max_num_bins,
impose_null_spaces == 0 ? false : true,
matrix_type,
*csr);
out_matrix->row_offsets = csr->row_offsets;
out_matrix->column_ids = csr->column_ids;
out_matrix->values = csr->values;
out_matrix->reserved = csr;
return ret;
}
int ssa_d_ids(
int num_rows,
int num_cols,
const double* col_values,
int col_leading_dim,
double sparsity_ratio,
double sparsity_norm_p,
int min_num_nnz_per_row,
int min_num_nnz_per_col,
enum ssa_matrix_type matrix_type,
struct ssa_d_csr* out_matrix)
{
ssa_csr<int, int, double>* csr = new (std::nothrow) ssa_csr<int, int, double>;
if(!csr)
{
assert(false);
internal_api_error_set_last("ssa_d_ids: Memory allocation failed.");
return 1;
}
int ret = ssa_ids(
num_rows, num_cols,
col_values, col_leading_dim,
sparsity_ratio, sparsity_norm_p,
min_num_nnz_per_row, min_num_nnz_per_col,
matrix_type,
*csr);
out_matrix->row_offsets = csr->row_offsets;
out_matrix->column_ids = csr->column_ids;
out_matrix->values = csr->values;
out_matrix->reserved = csr;
return ret;
}
// -----------------------------------------------------------------------------
int ssa_s_pat(
int num_rows,
int num_cols,
const float* col_values,
int col_leading_dim,
const int* row_offsets,
const int* column_ids,
int max_num_bins,
int impose_null_spaces,
enum ssa_matrix_type matrix_type,
float* out_row_values)
{
int ret = ssa_pat(
num_rows, num_cols,
col_values, col_leading_dim,
row_offsets, column_ids,
max_num_bins,
impose_null_spaces == 0 ? false : true,
matrix_type,
out_row_values);
return ret;
}
int ssa_s_lpn(
int num_rows,
int num_cols,
const float* col_values,
int col_leading_dim,
float sparsity_ratio,
float sparsity_norm_p,
int max_num_bins,
int impose_null_spaces,
enum ssa_matrix_type matrix_type,
struct ssa_s_csr* out_matrix)
{
ssa_csr<int, int, float>* csr = new (std::nothrow) ssa_csr<int, int, float>;
if(!csr)
{
assert(false);
internal_api_error_set_last("ssa_s_lpn: Memory allocation failed.");
return 1;
}
int ret = ssa_lpn(
num_rows, num_cols,
col_values, col_leading_dim,
sparsity_ratio, sparsity_norm_p,
max_num_bins,
impose_null_spaces == 0 ? false : true,
matrix_type,
*csr);
out_matrix->row_offsets = csr->row_offsets;
out_matrix->column_ids = csr->column_ids;
out_matrix->values = csr->values;
out_matrix->reserved = csr;
return ret;
}
int ssa_s_ids(
int num_rows,
int num_cols,
const float* col_values,
int col_leading_dim,
float sparsity_ratio,
float sparsity_norm_p,
int min_num_nnz_per_row,
int min_num_nnz_per_col,
enum ssa_matrix_type matrix_type,
struct ssa_s_csr* out_matrix)
{
ssa_csr<int, int, float>* csr = new (std::nothrow) ssa_csr<int, int, float>;
if(!csr)
{
assert(false);
internal_api_error_set_last("ssa_s_ids: Memory allocation failed.");
return 1;
}
int ret = ssa_ids(
num_rows, num_cols,
col_values, col_leading_dim,
sparsity_ratio, sparsity_norm_p,
min_num_nnz_per_row, min_num_nnz_per_col,
matrix_type,
*csr);
out_matrix->row_offsets = csr->row_offsets;
out_matrix->column_ids = csr->column_ids;
out_matrix->values = csr->values;
out_matrix->reserved = csr;
return ret;
}
// -----------------------------------------------------------------------------
int ssa_z_pat(
int num_rows,
int num_cols,
const double* col_values,
int col_leading_dim,
const int* row_offsets,
const int* column_ids,
int max_num_bins,
int impose_null_spaces,
enum ssa_matrix_type matrix_type,
double* out_row_values)
{
int ret = ssa_pat<int,int,std::complex<double> >(
num_rows, num_cols,
reinterpret_cast<const std::complex<double>*>(col_values), col_leading_dim,
row_offsets, column_ids,
max_num_bins,
impose_null_spaces == 0 ? false : true,
matrix_type,
reinterpret_cast<std::complex<double>*>(out_row_values));
return ret;
}
int ssa_z_lpn(
int num_rows,
int num_cols,
const double* col_values,
int col_leading_dim,
double sparsity_ratio,
double sparsity_norm_p,
int max_num_bins,
int impose_null_spaces,
enum ssa_matrix_type matrix_type,
struct ssa_z_csr* out_matrix)
{
ssa_csr<int, int, std::complex<double> >* csr = new (std::nothrow) ssa_csr<int, int, std::complex<double> >;
if(!csr)
{
assert(false);
internal_api_error_set_last("ssa_z_lpn: Memory allocation failed.");
return 1;
}
int ret = ssa_lpn(
num_rows, num_cols,
reinterpret_cast<const std::complex<double>*>(col_values), col_leading_dim,
sparsity_ratio, sparsity_norm_p,
max_num_bins,
impose_null_spaces == 0 ? false : true,
matrix_type,
*csr);
out_matrix->row_offsets = csr->row_offsets;
out_matrix->column_ids = csr->column_ids;
out_matrix->values = reinterpret_cast<double*>(csr->values);
out_matrix->reserved = csr;
return ret;
}
int ssa_z_ids(
int num_rows,
int num_cols,
const double* col_values,
int col_leading_dim,
double sparsity_ratio,
double sparsity_norm_p,
int min_num_nnz_per_row,
int min_num_nnz_per_col,
enum ssa_matrix_type matrix_type,
struct ssa_z_csr* out_matrix)
{
ssa_csr<int, int, std::complex<double> >* csr = new (std::nothrow) ssa_csr<int, int, std::complex<double> >;
if(!csr)
{
assert(false);
internal_api_error_set_last("ssa_z_ids: Memory allocation failed.");
return 1;
}
int ret = ssa_ids(
num_rows, num_cols,
reinterpret_cast<const std::complex<double>*>(col_values), col_leading_dim,
sparsity_ratio, sparsity_norm_p,
min_num_nnz_per_row, min_num_nnz_per_col,
matrix_type,
*csr);
out_matrix->row_offsets = csr->row_offsets;
out_matrix->column_ids = csr->column_ids;
out_matrix->values = reinterpret_cast<double*>(csr->values);
out_matrix->reserved = csr;
return ret;
}
// -----------------------------------------------------------------------------
int ssa_c_pat(
int num_rows,
int num_cols,
const float* col_values,
int col_leading_dim,
const int* row_offsets,
const int* column_ids,
int max_num_bins,
int impose_null_spaces,
enum ssa_matrix_type matrix_type,
float* out_row_values)
{
int ret = ssa_pat<int,int,std::complex<float> >(
num_rows, num_cols,
reinterpret_cast<const std::complex<float>*>(col_values), col_leading_dim,
row_offsets, column_ids,
max_num_bins,
impose_null_spaces == 0 ? false : true,
matrix_type,
reinterpret_cast<std::complex<float>*>(out_row_values));
return ret;
}
int ssa_c_lpn(
int num_rows,
int num_cols,
const float* col_values,
int col_leading_dim,
float sparsity_ratio,
float sparsity_norm_p,
int max_num_bins,
int impose_null_spaces,
enum ssa_matrix_type matrix_type,
struct ssa_c_csr* out_matrix)
{
ssa_csr<int, int, std::complex<float> >* csr = new (std::nothrow) ssa_csr<int, int, std::complex<float> >;
if(!csr)
{
assert(false);
internal_api_error_set_last("ssa_c_lpn: Memory allocation failed.");
return 1;
}
int ret = ssa_lpn(
num_rows, num_cols,
reinterpret_cast<const std::complex<float>*>(col_values), col_leading_dim,
sparsity_ratio, sparsity_norm_p,
max_num_bins,
impose_null_spaces == 0 ? false : true,
matrix_type,
*csr);
out_matrix->row_offsets = csr->row_offsets;
out_matrix->column_ids = csr->column_ids;
out_matrix->values = reinterpret_cast<float*>(csr->values);
out_matrix->reserved = csr;
return ret;
}
int ssa_c_ids(
int num_rows,
int num_cols,
const float* col_values,
int col_leading_dim,
float sparsity_ratio,
float sparsity_norm_p,
int min_num_nnz_per_row,
int min_num_nnz_per_col,
enum ssa_matrix_type matrix_type,
struct ssa_c_csr* out_matrix)
{
ssa_csr<int, int, std::complex<float> >* csr = new (std::nothrow) ssa_csr<int, int, std::complex<float> >;
if(!csr)
{
assert(false);
internal_api_error_set_last("ssa_c_ids: Memory allocation failed.");
return 1;
}
int ret = ssa_ids(
num_rows, num_cols,
reinterpret_cast<const std::complex<float>*>(col_values), col_leading_dim,
sparsity_ratio, sparsity_norm_p,
min_num_nnz_per_row, min_num_nnz_per_col,
matrix_type,
*csr);
out_matrix->row_offsets = csr->row_offsets;
out_matrix->column_ids = csr->column_ids;
out_matrix->values = reinterpret_cast<float*>(csr->values);
out_matrix->reserved = csr;
return ret;
}
// -----------------------------------------------------------------------------
void ssa_d_csr_deallocate(struct ssa_d_csr* matrix)
{
if(matrix)
{
matrix->row_offsets = 0;
matrix->column_ids = 0;
matrix->values = 0;
delete_catch(
reinterpret_cast<
const ssa_csr<int, int, double>*>(
matrix->reserved), "ssa_d_csr_deallocate");
matrix->reserved = 0;
}
}
void ssa_s_csr_deallocate(struct ssa_s_csr* matrix)
{
if(matrix)
{
matrix->row_offsets = 0;
matrix->column_ids = 0;
matrix->values = 0;
delete_catch(
reinterpret_cast<
const ssa_csr<int, int, float>*>(
matrix->reserved), "ssa_s_csr_deallocate");
matrix->reserved = 0;
}
}
void ssa_z_csr_deallocate(struct ssa_z_csr* matrix)
{
if(matrix)
{
matrix->row_offsets = 0;
matrix->column_ids = 0;
matrix->values = 0;
delete_catch(
reinterpret_cast<
const ssa_csr<int, int, std::complex<double> >*>(
matrix->reserved), "ssa_z_csr_deallocate");
matrix->reserved = 0;
}
}
void ssa_c_csr_deallocate(struct ssa_c_csr* matrix)
{
if(matrix)
{
matrix->row_offsets = 0;
matrix->column_ids = 0;
matrix->values = 0;
delete_catch(
reinterpret_cast<
const ssa_csr<int, int, std::complex<float> >*>(
matrix->reserved), "ssa_c_csr_deallocate");
matrix->reserved = 0;
}
}
// -----------------------------------------------------------------------------
// instantiate the template functions explicitly.
#define SSA_INSTANTIATE_PAT_LPN(index, offset, scalar) \
\
template TXSSA_API int ssa_pat<index, offset, scalar>( \
index num_rows, \
index num_cols, \
const scalar* col_values, \
index col_leading_dim, \
const offset* row_offsets, \
const index* column_ids, \
offset max_num_bins, \
bool impose_null_spaces, \
enum ssa_matrix_type matrix_type, \
scalar* out_row_values); \
\
template TXSSA_API int ssa_lpn<index, offset, scalar>( \
index num_rows, \
index num_cols, \
const scalar* col_values, \
index col_leading_dim, \
scalar sparsity_ratio, \
scalar sparsity_norm_p, \
offset max_num_bins, \
bool impose_null_spaces, \
enum ssa_matrix_type matrix_type, \
ssa_csr<index, offset, scalar>& out_matrix); \
\
template TXSSA_API int ssa_pat<index, offset, std::complex<scalar> >( \
index num_rows, \
index num_cols, \
const std::complex<scalar>* col_values, \
index col_leading_dim, \
const offset* row_offsets, \
const index* column_ids, \
offset max_num_bins, \
bool impose_null_spaces, \
enum ssa_matrix_type matrix_type, \
std::complex<scalar>* out_row_values); \
\
template TXSSA_API int ssa_lpn<index, offset, scalar>( \
index num_rows, \
index num_cols, \
const std::complex<scalar>* col_values, \
index col_leading_dim, \
scalar sparsity_ratio, \
scalar sparsity_norm_p, \
offset max_num_bins, \
bool impose_null_spaces, \
enum ssa_matrix_type matrix_type, \
ssa_csr<index, offset, std::complex<scalar> >& out_matrix)
#define SSA_INSTANTIATE_IDS(index, offset, scalar) \
template TXSSA_API int ssa_ids<index, offset, scalar>( \
index num_rows, \
index num_cols, \
const scalar* col_values, \
index col_leading_dim, \
scalar sparsity_ratio, \
scalar sparsity_norm_p, \
index min_num_nnz_per_row, \
index min_num_nnz_per_col, \
enum ssa_matrix_type matrix_type, \
ssa_csr<index, offset, scalar>& out_matrix); \
template TXSSA_API int ssa_ids<index, offset, scalar>( \
index num_rows, \
index num_cols, \
const std::complex<scalar>* col_values, \
index col_leading_dim, \
scalar sparsity_ratio, \
scalar sparsity_norm_p, \
index min_num_nnz_per_row, \
index min_num_nnz_per_col, \
enum ssa_matrix_type matrix_type, \
ssa_csr<index, offset, std::complex<scalar> >& out_matrix)
#define SSA_INSTANTIATE_CSR(index, offset, scalar) \
template ssa_csr<index, offset, scalar>::ssa_csr(); \
template ssa_csr<index, offset, scalar>::~ssa_csr(); \
template ssa_csr<index, offset, std::complex<scalar> >::ssa_csr(); \
template ssa_csr<index, offset, std::complex<scalar> >::~ssa_csr()
#define SSA_INSTANTIATE_PAT_LPN_IDS_CSR(index, offset, scalar) \
SSA_INSTANTIATE_PAT_LPN(index, offset, scalar); \
SSA_INSTANTIATE_PAT_LPN(unsigned index, unsigned offset, scalar); \
SSA_INSTANTIATE_IDS(index, offset, scalar); \
SSA_INSTANTIATE_IDS(unsigned index, unsigned offset, scalar); \
SSA_INSTANTIATE_CSR(index, offset, scalar); \
SSA_INSTANTIATE_CSR(unsigned index, unsigned offset, scalar)
#define SSA_INSTANTIATE_PAT_LPN_IDS_CSR_all_float(index, offset) \
SSA_INSTANTIATE_PAT_LPN_IDS_CSR(index, offset, float); \
SSA_INSTANTIATE_PAT_LPN_IDS_CSR(index, offset, double)
// Commenting out the less used ones.
//SSA_INSTANTIATE_PAT_LPN_IDS_CSR_all_float(char, char);
//SSA_INSTANTIATE_PAT_LPN_IDS_CSR_all_float(char, short);
//SSA_INSTANTIATE_PAT_LPN_IDS_CSR_all_float(char, int);
//SSA_INSTANTIATE_PAT_LPN_IDS_CSR_all_float(char, long);
//SSA_INSTANTIATE_PAT_LPN_IDS_CSR_all_float(short, short);
//SSA_INSTANTIATE_PAT_LPN_IDS_CSR_all_float(short, int);
//SSA_INSTANTIATE_PAT_LPN_IDS_CSR_all_float(short, long);
SSA_INSTANTIATE_PAT_LPN_IDS_CSR_all_float(int, int);
//SSA_INSTANTIATE_PAT_LPN_IDS_CSR_all_float(int, long);
#if defined(__x86_64__)
SSA_INSTANTIATE_PAT_LPN_IDS_CSR_all_float(long, long);
#endif
#if defined(_WIN64)
SSA_INSTANTIATE_PAT_LPN_IDS_CSR_all_float(long long, long long);
#endif
| [
"[email protected]@5b5e8932-273f-bf1a-7869-30ea985f000d"
] | [email protected]@5b5e8932-273f-bf1a-7869-30ea985f000d |
0f88ae8effb1ed4b3e970e7d66183786215369b6 | 9c248473526c9d2cbc1f30ea8536bc86e17c1b41 | /system/ulib/trace-provider/trace_provider.fidl.cpp | ecd9675c58617cdd26b8e4d6445045b5256b557f | [
"BSD-3-Clause",
"MIT"
] | permissive | zy1911/zircon | 1f44315762f4c9dbdc22daddaf8cd9a3e0e2abf5 | 8e4ae4064660f2c7fe8c221befbf9d0aefbdde01 | refs/heads/master | 2020-03-25T04:22:22.482646 | 2018-08-03T05:38:54 | 2018-08-03T06:05:31 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,946 | cpp | // Copyright 2018 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
// This was machine generated with:
// bash$ fidlc --c-header trace_provider.fidl.h --tables trace_provider.fidl.cpp
// --files system/fidl/tracelink/tracelink.fidl
// There are no differences with the machine generated version except the
// addition of this text (up to "End of additions ...").
// It is checked in to workaround these problems:
// - zircon's build system doesn't support transitive dependencies
// - duplicate copy of tracelink is generated and compiled in garnet
// - generated code for Interfaces is different than what we're using:
// struct vs zx_handle_t
#include "trace_provider.fidl.h"
// End of additions to machine-generated file.
// WARNING: This file is machine generated by fidlc.
#include <lib/fidl/internal.h>
extern "C" {
static const fidl_type_t HandlevmononnullableTable = fidl_type_t(::fidl::FidlCodedHandle(ZX_OBJ_TYPE_VMO, ::fidl::kNonnullable));
static const fidl_type_t HandleeventpairnonnullableTable = fidl_type_t(::fidl::FidlCodedHandle(ZX_OBJ_TYPE_EVENTPAIR, ::fidl::kNonnullable));
static const fidl_type_t String100nonnullableTable = fidl_type_t(::fidl::FidlCodedString(100, ::fidl::kNonnullable));
static const fidl_type_t VectorString100nonnullable100nonnullableTable = fidl_type_t(::fidl::FidlCodedVector(&String100nonnullableTable, 100, 16, ::fidl::kNonnullable));
extern const fidl_type_t fuchsia_tracelink_ProviderStartRequestTable;
static const ::fidl::FidlField fuchsia_tracelink_ProviderStartRequestFields[] = {
::fidl::FidlField(&HandlevmononnullableTable, 16),
::fidl::FidlField(&HandleeventpairnonnullableTable, 20),
::fidl::FidlField(&VectorString100nonnullable100nonnullableTable, 24)
};
const fidl_type_t fuchsia_tracelink_ProviderStartRequestTable = fidl_type_t(::fidl::FidlCodedStruct(fuchsia_tracelink_ProviderStartRequestFields, 3, 40, ""));
extern const fidl_type_t fuchsia_tracelink_ProviderStopRequestTable;
static const ::fidl::FidlField fuchsia_tracelink_ProviderStopRequestFields[] = {};
const fidl_type_t fuchsia_tracelink_ProviderStopRequestTable = fidl_type_t(::fidl::FidlCodedStruct(fuchsia_tracelink_ProviderStopRequestFields, 0, 16, ""));
static const fidl_type_t fuchsia_tracelink_ProviderInterfacenonnullableTable = fidl_type_t(::fidl::FidlCodedHandle(ZX_OBJ_TYPE_CHANNEL, ::fidl::kNonnullable));
extern const fidl_type_t fuchsia_tracelink_RegistryRegisterTraceProviderRequestTable;
static const ::fidl::FidlField fuchsia_tracelink_RegistryRegisterTraceProviderRequestFields[] = {
::fidl::FidlField(&fuchsia_tracelink_ProviderInterfacenonnullableTable, 16)
};
const fidl_type_t fuchsia_tracelink_RegistryRegisterTraceProviderRequestTable = fidl_type_t(::fidl::FidlCodedStruct(fuchsia_tracelink_RegistryRegisterTraceProviderRequestFields, 1, 20, ""));
} // extern "C"
| [
"[email protected]"
] | |
7b1ba9a4c9559f2dd46482163ed7590a8389fcbd | dfca6cf85ae80d7bf649e61600bf0214701621d3 | /djc_math/transform.hpp | 3e7cb2bb08ad303bc9cfff3f0c2c4f0618848fbb | [
"MIT"
] | permissive | DanielJamesCollier/djc_math | 0b67bd47a6354987ffa8364473c3b68c8a43c256 | 5f97d122947f345288f2b3dcfbb970dd85dc973f | refs/heads/master | 2021-01-19T08:22:29.623426 | 2017-11-07T12:09:43 | 2017-11-07T12:09:43 | 87,623,170 | 2 | 0 | null | 2017-10-03T11:46:56 | 2017-04-08T09:33:41 | C++ | UTF-8 | C++ | false | false | 3,004 | hpp | #ifndef DJC_MATH_TRANSFORM_HPP
#define DJC_MATH_TRANSFORM_HPP
// djc_math
#include "vec3.hpp"
#include "mat3.hpp"
#include "mat4.hpp"
#include "config.hpp"
// std
#include <array>
#include <cmath> // std::sqrt - std::sin - std::cos - std::tan
namespace djc::math {
// mat3 //
//------------------------------------------------------------
template<typename T>
constexpr mat3<T>
create_mat3_identity_matrix() noexcept;
//------------------------------------------------------------
template<typename T>
mat3<T>
create_mat3_rotation_matrix(vec3<T> const & vec) noexcept;
// mat4 //
//------------------------------------------------------------
template<typename T>
constexpr mat4<T>
create_mat4_identity_matrix() noexcept;
//------------------------------------------------------------
template<typename T>
constexpr mat4<T>
create_mat4_translation_matrix(vec3<T> const & vec) noexcept;
//------------------------------------------------------------
template<typename T>
mat4<T>
create_mat4_rotation_matrix(vec3<T> const & vec) noexcept;
//------------------------------------------------------------
template<typename T>
constexpr mat4<T>
create_mat4_scale_matrix(vec3<T> const & vec) noexcept;
//------------------------------------------------------------
template<typename T>
mat4<T>
create_mat4_model_matrix(vec3<T> const & position, vec3<T> const & rotation, vec3<T> const & scale) noexcept;
//------------------------------------------------------------
template<typename T>
constexpr mat4<T>
create_mat4_orthographic_matrix(int width, int height, T zNear, T zFar) noexcept;
//------------------------------------------------------------
template<typename T>
mat4<T>
create_mat4_projection_matrix(T fov, T aspect, T zNear, T zFar) noexcept;
//------------------------------------------------------------
template<typename T>
constexpr mat4<T>
create_mat4_view_matrix(vec3<T> const & eye, vec3<T> const & centre, vec3<T> const & up) noexcept;
//------------------------------------------------------------
template<typename T>
constexpr mat4<T>
create_mat4_birds_eye_view_matrix() noexcept;
//------------------------------------------------------------
template<typename T>
constexpr mat4<T>
create_mat4_screenspace_transform(int half_width, int half_height) noexcept;
// Vector operations //
//------------------------------------------------------------
template<typename T>
void
transform(vec4<T> & vec, mat4<T> const & transformation);
//------------------------------------------------------------
template<typename T>
mat3<T>
rotate(T angle, vec3<T> const & axis) noexcept;
//------------------------------------------------------------
template<typename T>
mat4<T>
rotate(T angle, vec4<T> const & axis) noexcept;
} // namespace djc::math
#include "inline/transform_inl.hpp"
#endif // DJC_MATH_TRANSFORM_HPP
| [
"[email protected]"
] | |
ea05fa975b035f47d1af374eadc0ebaa26adfa58 | 6d3bb1aee1f74255cc7dd385c84c423d8335b889 | /tests/MultiviewTest.cc | 8ab12b46da19635554244ee66bef0ebfa84c2358 | [] | no_license | RuntimeComputing/cppEDM | b8a9568aa0be9944ee4209d43719128c0fc2c442 | fd21fe7a19e4df16a25e932b07ae9d481fe47cc6 | refs/heads/master | 2021-05-18T15:22:36.657225 | 2020-03-22T16:14:30 | 2020-03-22T16:14:30 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,186 | cc | // Multiview Test
#include "TestCommon.h"
int main( int argc, char *argv[] ) {
//---------------------------------------------------------
// Load valid cppEDM output
//---------------------------------------------------------
DataFrame < double > validCppPredict( "./data/",
"Multiview_pred_valid.csv" );
DataFrame < double > validCppCombos( "./data/",
"Multiview_combos_valid.csv",
true ); // noTime = true
// Generate new cppEDM output
MultiviewValues MV = Multiview( "../data/",
"block_3sp.csv",
"./",
"MultiviewBlock3sp.csv",
"1 100",
"101 198",
3, // E
1, // Tp
0, // knn
-1, // tau
"x_t y_t z_t", // columns
"x_t", // target,
0, // multiview
0, // exclusionRadius
false, // verbose,
1 ); // nThreads
DataFrame< double > combos = MV.Combo_rho;
DataFrame< double > output = MV.Predictions;
combos.WriteData( "./", "Multiview_combos.csv" );
output.WriteData( "./", "Multiview_pred.csv" );
//VectorError ve = ComputeError( output.VectorColumnName("Observations"),
// output.VectorColumnName("Predictions"));
//std::cout << "Multiview(): rho " << ve.rho
// << " MAE " << ve.MAE << " RMSE " << ve.RMSE << std::endl;
// comparison
MakeTest ("Multiview combos test", validCppCombos, combos );
MakeTest ("Multiview prediction test", validCppPredict, output );
return 0;
}
| [
"[email protected]"
] | |
ec53fadd4f9a89c9633589dc45f9b995610a1a53 | 2483bfb32a5a2c0e94dd975a3acf14cfb0432d96 | /game/AI/CreatureAI.cpp | 560918d5c65dc43247708fa409b5b8e5d9a7cddc | [] | no_license | gragonvlad/MStorm-Master | c78680b314433b07aeec588f7113fff4766a50a4 | 5e3ef21f16b34cd6c795456811c91e4eb85a4bc0 | refs/heads/master | 2021-01-01T20:31:23.256784 | 2017-06-18T00:03:21 | 2017-06-18T00:03:21 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 9,655 | cpp | /*
* Copyright (C) 2008-2015 TrinityCore <http://www.trinitycore.org/>
* Copyright (C) 2005-2009 MaNGOS <http://getmangos.com/>
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the
* Free Software Foundation; either version 2 of the License, or (at your
* option) any later version.
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
* You should have received a copy of the GNU General Public License along
* with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include "CreatureAI.h"
#include "CreatureAIImpl.h"
#include "Creature.h"
#include "World.h"
#include "SpellMgr.h"
#include "Vehicle.h"
#include "Log.h"
#include "MapReference.h"
#include "Player.h"
#include "CreatureTextMgr.h"
//Disable CreatureAI when charmed
void CreatureAI::OnCharmed(bool /*apply*/)
{
//me->IsAIEnabled = !apply;*/
me->NeedChangeAI = true;
me->IsAIEnabled = false;
}
AISpellInfoType* UnitAI::AISpellInfo;
AISpellInfoType* GetAISpellInfo(uint32 i) { return &CreatureAI::AISpellInfo[i]; }
void CreatureAI::Talk(uint8 id, WorldObject const* whisperTarget /*= nullptr*/)
{
sCreatureTextMgr->SendChat(me, id, whisperTarget);
}
void CreatureAI::DoZoneInCombat(Creature* creature /*= NULL*/, float maxRangeToNearestTarget /* = 50.0f*/)
{
if (!creature)
creature = me;
if (!creature->CanHaveThreatList())
return;
Map* map = creature->GetMap();
if (!map->IsDungeon()) //use IsDungeon instead of Instanceable, in case battlegrounds will be instantiated
{
TC_LOG_ERROR("misc", "DoZoneInCombat call for map that isn't an instance (creature entry = %d)", creature->GetTypeId() == TYPEID_UNIT ? creature->ToCreature()->GetEntry() : 0);
return;
}
if (!creature->HasReactState(REACT_PASSIVE) && !creature->GetVictim())
{
if (Unit* nearTarget = creature->SelectNearestTarget(maxRangeToNearestTarget))
creature->AI()->AttackStart(nearTarget);
else if (creature->IsSummon())
{
if (Unit* summoner = creature->ToTempSummon()->GetSummoner())
{
Unit* target = summoner->getAttackerForHelper();
if (!target && summoner->CanHaveThreatList() && !summoner->getThreatManager().isThreatListEmpty())
target = summoner->getThreatManager().getHostilTarget();
if (target && (creature->IsFriendlyTo(summoner) || creature->IsHostileTo(target)))
creature->AI()->AttackStart(target);
}
}
}
// Intended duplicated check, the code above this should select a victim
// If it can't find a suitable attack target then we should error out.
if (!creature->HasReactState(REACT_PASSIVE) && !creature->GetVictim())
{
TC_LOG_ERROR("misc", "DoZoneInCombat called for creature that has empty threat list (creature entry = %u)", creature->GetEntry());
return;
}
Map::PlayerList const& playerList = map->GetPlayers();
if (playerList.isEmpty())
return;
for (Map::PlayerList::const_iterator itr = playerList.begin(); itr != playerList.end(); ++itr)
{
if (Player* player = itr->GetSource())
{
if (player->IsGameMaster())
continue;
if (player->IsAlive())
{
creature->SetInCombatWith(player);
player->SetInCombatWith(creature);
creature->AddThreat(player, 0.0f);
}
/* Causes certain things to never leave the threat list (Priest Lightwell, etc):
for (Unit::ControlList::const_iterator itr = player->m_Controlled.begin(); itr != player->m_Controlled.end(); ++itr)
{
creature->SetInCombatWith(*itr);
(*itr)->SetInCombatWith(creature);
creature->AddThreat(*itr, 0.0f);
}*/
}
}
}
// scripts does not take care about MoveInLineOfSight loops
// MoveInLineOfSight can be called inside another MoveInLineOfSight and cause stack overflow
void CreatureAI::MoveInLineOfSight_Safe(Unit* who)
{
if (m_MoveInLineOfSight_locked == true)
return;
m_MoveInLineOfSight_locked = true;
MoveInLineOfSight(who);
m_MoveInLineOfSight_locked = false;
}
void CreatureAI::MoveInLineOfSight(Unit* who)
{
if (me->GetVictim())
return;
if (me->GetCreatureType() == CREATURE_TYPE_NON_COMBAT_PET) // non-combat pets should just stand there and look good;)
return;
if (me->CanStartAttack(who, false))
AttackStart(who);
//else if (who->GetVictim() && me->IsFriendlyTo(who)
// && me->IsWithinDistInMap(who, sWorld->getIntConfig(CONFIG_CREATURE_FAMILY_ASSISTANCE_RADIUS))
// && me->CanStartAttack(who->GetVictim(), true)) /// @todo if we use true, it will not attack it when it arrives
// me->GetMotionMaster()->MoveChase(who->GetVictim());
}
// Distract creature, if player gets too close while stealthed/prowling
void CreatureAI::TriggerAlert(Unit const* who) const
{
// If there's no target, or target isn't a player do nothing
if (!who || who->GetTypeId() != TYPEID_PLAYER)
return;
// If this unit isn't an NPC, is already distracted, is in combat, is confused, stunned or fleeing, do nothing
if (me->GetTypeId() != TYPEID_UNIT || me->IsInCombat() || me->HasUnitState(UNIT_STATE_CONFUSED | UNIT_STATE_STUNNED | UNIT_STATE_FLEEING | UNIT_STATE_DISTRACTED))
return;
// Only alert for hostiles!
if (me->IsCivilian() || me->HasReactState(REACT_PASSIVE) || !me->IsHostileTo(who) || !me->_IsTargetAcceptable(who))
return;
// Send alert sound (if any) for this creature
me->SendAIReaction(AI_REACTION_ALERT);
// Face the unit (stealthed player) and set distracted state for 5 seconds
me->SetFacingTo(me->GetAngle(who->GetPositionX(), who->GetPositionY()));
me->StopMoving();
me->GetMotionMaster()->MoveDistract(5 * IN_MILLISECONDS);
}
void CreatureAI::EnterEvadeMode()
{
if (!_EnterEvadeMode())
return;
TC_LOG_DEBUG("entities.unit", "Creature %u enters evade mode.", me->GetEntry());
if (!me->GetVehicle()) // otherwise me will be in evade mode forever
{
if (Unit* owner = me->GetCharmerOrOwner())
{
me->GetMotionMaster()->Clear(false);
me->GetMotionMaster()->MoveFollow(owner, PET_FOLLOW_DIST, me->GetFollowAngle(), MOTION_SLOT_ACTIVE);
}
else
{
// Required to prevent attacking creatures that are evading and cause them to reenter combat
// Does not apply to MoveFollow
me->AddUnitState(UNIT_STATE_EVADE);
me->GetMotionMaster()->MoveTargetedHome();
}
}
Reset();
if (me->IsVehicle()) // use the same sequence of addtoworld, aireset may remove all summons!
me->GetVehicleKit()->Reset(true);
}
/*void CreatureAI::AttackedBy(Unit* attacker)
{
if (!me->GetVictim())
AttackStart(attacker);
}*/
void CreatureAI::SetGazeOn(Unit* target)
{
if (me->IsValidAttackTarget(target))
{
AttackStart(target);
me->SetReactState(REACT_PASSIVE);
}
}
bool CreatureAI::UpdateVictimWithGaze()
{
if (!me->IsInCombat())
return false;
if (me->HasReactState(REACT_PASSIVE))
{
if (me->GetVictim())
return true;
else
me->SetReactState(REACT_AGGRESSIVE);
}
if (Unit* victim = me->SelectVictim())
AttackStart(victim);
return me->GetVictim() != nullptr;
}
bool CreatureAI::UpdateVictim()
{
if (!me->IsInCombat())
return false;
if (!me->HasReactState(REACT_PASSIVE))
{
if (Unit* victim = me->SelectVictim())
AttackStart(victim);
return me->GetVictim() != nullptr;
}
else if (me->getThreatManager().isThreatListEmpty())
{
EnterEvadeMode();
return false;
}
return true;
}
bool CreatureAI::_EnterEvadeMode()
{
if (!me->IsAlive())
return false;
// don't remove vehicle auras, passengers aren't supposed to drop off the vehicle
// don't remove clone caster on evade (to be verified)
me->RemoveAllAurasExceptType(SPELL_AURA_CONTROL_VEHICLE, SPELL_AURA_CLONE_CASTER, 710000, 700000);
// sometimes bosses stuck in combat?
me->DeleteThreatList();
me->CombatStop(true);
me->LoadCreaturesAddon();
me->SetLootRecipient(NULL);
me->ResetPlayerDamageReq();
me->SetLastDamagedTime(0);
if (me->IsInEvadeMode())
return false;
return true;
}
Creature* CreatureAI::DoSummon(uint32 entry, const Position& pos, uint32 despawnTime, TempSummonType summonType)
{
return me->SummonCreature(entry, pos, summonType, despawnTime);
}
Creature* CreatureAI::DoSummon(uint32 entry, WorldObject* obj, float radius, uint32 despawnTime, TempSummonType summonType)
{
Position pos = obj->GetRandomNearPosition(radius);
return me->SummonCreature(entry, pos, summonType, despawnTime);
}
Creature* CreatureAI::DoSummonFlyer(uint32 entry, WorldObject* obj, float flightZ, float radius, uint32 despawnTime, TempSummonType summonType)
{
Position pos = obj->GetRandomNearPosition(radius);
pos.m_positionZ += flightZ;
return me->SummonCreature(entry, pos, summonType, despawnTime);
}
| [
"[email protected]"
] | |
e5cafede85df4ef600cb449f85c76025d49d693f | a52ca01fcd1250ce5dbbdd969f85cbd72255d69f | /EngineUAB/Code/Videogame/Characters/Enemies/Wolf/AnimationStates/WolfRunRunAttackAnimationState.cpp | 1d71a7036b0f82302bf6c0050f75e0f9cd7f41cc | [] | no_license | kusku/red-forest | b089c8a76ed211ec126e07a32cd5c2cee90f6c12 | 24a104f06cce6031a66a6a920c0c170d059f38fb | refs/heads/master | 2021-01-10T08:00:46.367896 | 2012-10-26T02:35:34 | 2012-10-26T02:35:34 | 53,213,277 | 2 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,880 | cpp | #include "WolfRunRunAttackAnimationState.h"
#include "Characters\StatesDefs.h"
#include "Characters\Enemies\Wolf\Wolf.h"
#include "RenderableObjects\AnimatedModel\AnimatedInstanceModel.h"
#if defined(_DEBUG)
#include "Memory\MemLeaks.h"
#endif
// -----------------------------------------
// CONSTRUCTORS / DESTRUCTOR
// -----------------------------------------
CWolfRunRunAttackAnimationState::CWolfRunRunAttackAnimationState( CCharacter* _pCharacter )
: CState ( _pCharacter, "CWolfRunRunAttackAnimationState")
, m_pWolf ( NULL )
{
}
CWolfRunRunAttackAnimationState::CWolfRunRunAttackAnimationState( CCharacter* _pCharacter, const std::string &_Name )
: CState (_pCharacter, _Name)
, m_pWolf ( NULL )
{
}
CWolfRunRunAttackAnimationState::~CWolfRunRunAttackAnimationState( void )
{
if (m_pWolf)
{
int l_Num = m_pWolf->GetAnimationID(WOLF_RUN_STATE);
m_pWolf->GetAnimatedModel()->ClearCycle( l_Num, 0.3f );
}
m_pWolf = NULL;
}
// -----------------------------------------
// MAIN METHODS
// -----------------------------------------
void CWolfRunRunAttackAnimationState::Execute( CCharacter*, float _ElapsedTime )
{
}
void CWolfRunRunAttackAnimationState::OnEnter( CCharacter* _pCharacter )
{
if (!m_pWolf)
{
m_pWolf = dynamic_cast<CWolf*> (_pCharacter);
}
int l_Num = _pCharacter->GetAnimationID(WOLF_RUN_STATE);
m_pWolf->GetAnimatedModel()->BlendCycle( l_Num, 0.3f );
}
void CWolfRunRunAttackAnimationState::OnExit( CCharacter* _pCharacter )
{
if ( !m_pWolf )
{
// Almacenamos el enemigo
m_pWolf = dynamic_cast<CWolf*> (_pCharacter);
}
int l_Num = m_pWolf->GetAnimationID(WOLF_RUN_STATE);
m_pWolf->GetAnimatedModel()->ClearCycle( l_Num, 0.3f );
}
bool CWolfRunRunAttackAnimationState::OnMessage( CCharacter*, const STelegram& _Telegram )
{
return false;
}
| [
"jordi.arenas.vigo@38b49c57-6b6f-6c24-9f89-8eb2c450b9d7"
] | jordi.arenas.vigo@38b49c57-6b6f-6c24-9f89-8eb2c450b9d7 |
5b5b0df9fa1819732c004879b2b6b205d8799981 | 8aa7e5a09b0dcc691a03beb07e42d77a5da8c423 | /frameworks/LSTG/LuaWrapper/LW_Frame.cpp | 3638122da83246a814ec27f51e65c8beb5b34b42 | [
"MIT"
] | permissive | StevenCoober/LuaSTG-x | b76504a149314636d7b74332b631787f15e1328a | cde29fd92436163f1cfc1196dd1f908cb5ead255 | refs/heads/master | 2023-05-30T08:03:18.928277 | 2021-06-11T09:58:27 | 2021-06-11T09:58:27 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 6,389 | cpp | #include "LW_Frame.h"
#include "AppFrame.h"
#include "Renderer.h"
#include "LogSystem.h"
#include "Util/Utility.h"
#include "Util/UtilLua.h"
#include "tolua_fix.h"
#include "CCLuaEngine.h"
#include "../Classes/XLuaModuleRegistry.h"
using namespace std;
using namespace lstg;
LUA_REGISTER_FUNC_DEF(lstg, SetFPS)
{
int v = luaL_checkinteger(L, 1);
if (v <= 0)
v = 60;
LAPP.setFPS(static_cast<uint32_t>(v));
return 0;
}
LUA_REGISTER_FUNC_DEF(lstg, GetFPS)
{
lua_pushnumber(L, LAPP.getFPS());
return 1;
}
LUA_REGISTER_FUNC_DEF(lstg, SetVsync)
{
LRR.setVsync(lua_toboolean(L, 1) != 0);
return 0;
}
LUA_REGISTER_FUNC_DEF(lstg, SystemLog)
{
static std::string prefix = "[LOG] ";
size_t size;
const auto s = luaL_checklstring(L, 1, &size);
LLOGGER.writeLine(prefix + std::string(s, size));
return 0;
}
LUA_REGISTER_FUNC_DEF(lstg, Print)
{
int n = lua_gettop(L);
lua_getglobal(L, "tostring"); // ... f
lua_pushstring(L, ""); // ... f s
for (int i = 1; i <= n; i++)
{
if (i > 1)
{
lua_pushstring(L, "\t"); // ... f s s
lua_concat(L, 2); // ... f s
}
lua_pushvalue(L, -2); // ... f s f
lua_pushvalue(L, i); // ... f s f arg[i]
lua_call(L, 1, 1); // ... f s ret
//const char* x = luaL_checkstring(L, -1);
lua_concat(L, 2); // ... f s
}
string info = luaL_checkstring(L, -1);
lua_pop(L, 2);
cocos2d::log("%s", info.c_str());
return 0;
}
LUA_REGISTER_FUNC_DEF(lstg, DoFile)
{
size_t size;
const auto s = luaL_checklstring(L, 1, &size);
const std::string path = { s,size };
lua_settop(L, 0);
LAPP.loadScript(path);
return lua_gettop(L);
}
LUA_REGISTER_FUNC_DEF(lstg, Snapshot)
{
size_t size;
const auto s = luaL_checklstring(L, 1, &size);
LAPP.snapShot({ s,size });
return 0;
}
LUA_REGISTER_FUNC_DEF(lstg, SetThreadPoolSize)
{
const auto val = luaL_checkinteger(L, 1);
if (val < 0)
return luaL_error(L, "invalid argument");
LTHP.resize(val);
return 0;
}
LUA_REGISTER_FUNC_DEF(lstg, GetThreadPoolSize)
{
lua_pushinteger(L, LTHP.size());
return 1;
}
LUA_REGISTER_FUNC_DEF(lstg, FrameInit)
{
if (!LAPP.frameInit())
{
return luaL_error(L, "FrameInit failed");
}
return 0;
}
LUA_REGISTER_FUNC_DEF(lstg, FrameReset)
{
if (!LAPP.frameReset())
{
return luaL_error(L, "FrameReset failed");
}
return 0;
}
LUA_REGISTER_FUNC_DEF(lstg, FrameEnd)
{
LAPP.frameShutdown();
return 0;
}
LUA_REGISTER_FUNC_DEF(lstg, GetPlatform)
{
#if CC_TARGET_PLATFORM == CC_PLATFORM_WIN32
lua_pushstring(L, "windows");
#elif CC_TARGET_PLATFORM == CC_PLATFORM_MAC
lua_pushstring(L, "mac");
#elif CC_TARGET_PLATFORM == CC_PLATFORM_LINUX
lua_pushstring(L, "linux");
#elif CC_TARGET_PLATFORM == CC_PLATFORM_ANDROID
lua_pushstring(L, "android");
#elif CC_TARGET_PLATFORM == CC_PLATFORM_IOS
lua_pushstring(L, "ios");
#else
lua_pushstring(L, "others");
#endif
return 1;
}
LUA_REGISTER_FUNC_DEF(lstg, GetBuildDate)
{
lua_pushstring(L, AppFrame::getBuildDate());
return 1;
}
LUA_REGISTER_FUNC_DEF(lstg, SetOnWriteLog)
{
static int refid = 0;
const auto handler = toluafix_ref_function(L, 1, 0);
if (handler == 0)
return luaL_error(L, "invalid argument");
if (refid != 0)
toluafix_remove_function_by_refid(L, refid);
refid = handler;
LLOGGER.setOnWrite([=](const std::string& str)
{
auto stack = cocos2d::LuaEngine::getInstance()->getLuaStack();
stack->pushString(str.c_str(), str.size());
stack->executeFunctionByHandler(handler, 1);
stack->clean();
});
return 0;
}
#ifdef MessageBox
#undef MessageBox
#endif
LUA_REGISTER_FUNC_DEF(lstg, MessageBox)
{
cocos2d::ccMessageBox(luaL_checkstring(L, 1), luaL_checkstring(L, 2));
return 0;
}
LUA_REGISTER_FUNC_DEF(lstg, XXHash32)
{
const auto type = lua_type(L, 1);
if (type == LUA_TNIL)
{
lua_pushinteger(L, XXHash32("nil", 3, type));
return 1;
}
if (type == LUA_TBOOLEAN)
{
const auto v = lua_toboolean(L, 1);
lua_pushinteger(L, XXHash32(&v, sizeof(v), type));
return 1;
}
if (type == LUA_TNUMBER)
{
const auto data = luaL_checknumber(L, 1);
lua_pushinteger(L, XXHash32(&data, sizeof(data), type));
return 1;
}
if (type == LUA_TLIGHTUSERDATA || type == LUA_TUSERDATA)
{
const auto p = lua_touserdata(L, 1);
if (!p)
lua_pushinteger(L, 0);
else
{
if (lua_gettop(L) >= 2)
lua_pushinteger(L, XXHash32(p, (size_t)luaL_checkinteger(L, 2), type));
else
lua_pushinteger(L, XXHash32(&p, sizeof(p), type));
}
return 1;
}
if (type == lua::LUA_TCDATA)
{
void* p = nullptr;
lua::luaval_to_cptr(L, 1, &p);
if (!p)
lua_pushinteger(L, 0);
else
{
if (lua_gettop(L) >= 2)
lua_pushinteger(L, XXHash32(p, (size_t)luaL_checkinteger(L, 2), type));
else
lua_pushinteger(L, XXHash32(&p, sizeof(p), type));
}
return 1;
}
size_t size = 0;
const auto str = lua_tolstring(L, 1, &size);
lua_pushinteger(L, XXHash32(str, size, type));
return 1;
}
LUA_REGISTER_FUNC_DEF(lstg, RC4XOR)
{
size_t key_size = 0;
const auto key = luaL_checklstring(L, 1, &key_size);
size_t size = 0;
const void* data = lua::luaval_to_const_data(L, 2, 3, &size);
if (data && size != 0)
{
vector<char> ret;
ret.resize(size);
RC4XOR({ key, key_size }, data, size, ret.data());
lua_pushlstring(L, ret.data(), ret.size());
}
else
{
lua_pushnil(L);
}
return 1;
}
LUA_REGISTER_FUNC_DEF(lstg, MD5Hash)
{
size_t size = 0;
const void* data = lua::luaval_to_const_data(L, 1, 2, &size);
if (data && size != 0)
{
const auto ret = MD5Hash(data, size);
if (!ret.empty())
{
lua_pushlstring(L, ret.data(), ret.size());
return 1;
}
}
lua_pushnil(L);
return 1;
}
LUA_REGISTER_FUNC_DEF(lstg, Base64Decode)
{
size_t size = 0;
const void* data = lua::luaval_to_const_data(L, 1, 2, &size);
if (data && size != 0)
{
unsigned char* decoded = nullptr;
const int length = cocos2d::base64Decode((const unsigned char*)data, (unsigned)size, &decoded);
if (decoded)
{
lua_pushlstring(L, (const char*)decoded, length);
free(decoded);
return 1;
}
}
lua_pushnil(L);
return 1;
}
LUA_REGISTER_FUNC_DEF(lstg, Base64Encode)
{
size_t size = 0;
const void* data = lua::luaval_to_const_data(L, 1, 2, &size);
if (data && size != 0)
{
char* encoded = nullptr;
const int length = cocos2d::base64Encode((const unsigned char*)data, (unsigned)size, &encoded);
if (encoded)
{
lua_pushlstring(L, encoded, length);
free(encoded);
return 1;
}
}
lua_pushnil(L);
return 1;
}
| [
"[email protected]"
] | |
0c30a2ff16ab94227af325d423e7bbce7785d12c | 288e945732ace900035694661b076ecc1d5d29e8 | /phantukhacnhau.cpp | 614d8ce8b1e841b1c6ccc34481d8779e1b9f3404 | [] | no_license | AtomicOrbital/CppSource | bf440704386cbd200f90b333a7c3c63dfee45abf | 29e312fb1f9b3f1be1c4aee86db8c1942b17bcbd | refs/heads/main | 2023-06-20T00:42:21.656879 | 2021-07-16T08:27:35 | 2021-07-16T08:27:35 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 449 | cpp | #include<bits/stdc++.h>
#define F first
#define S second
#define mp make_pair
#define FORT(i,a,b) for(int i=a;i<b;i++)
#define FORD(i,a,b) for(int i=(int)a-1;i>=b;i--)
using namespace std;
void prepare()
{
}
void solve()
{
int n;
cin >> n;
int a[n], b[n];
FORT(i,0,n) cin>> a[i];
FORT(i,0,n-1) cin>> b[i];
int d = 0;
for(; d < n-1; d++)
if (a[d] != b[d]) break;
cout<< d+1<<endl;
}
int main()
{
int t=1;
cin>>t;
while (t--) solve();
} | [
"[email protected]"
] | |
768383f000e89cab1183685da2a35a31a8c12880 | c766bece263e5149d0dbab04ea20308bf1191ab8 | /AdobeInDesignCCProductsSDK.2020/source/public/libs/publiclib/objectmodel/IDFactory.cpp | c1de39ead00531b9ccb20e356a12e94214218322 | [] | no_license | stevenstong/adobe-tools | 37a36868619db90984d5303187305c9da1e024f7 | c74d61d882363a91da4938fd525b97f83084cb2e | refs/heads/master | 2022-04-08T17:31:35.516938 | 2020-03-18T20:57:40 | 2020-03-18T20:57:40 | 248,061,036 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,710 | cpp | //========================================================================================
//
// $File: //depot/devtech/15.0/plugin/source/public/libs/publiclib/objectmodel/IDFactory.cpp $
//
// Owner: Michael Burbidge
//
// $Author: pmbuilder $
//
// $DateTime: 2019/10/11 10:48:01 $
//
// $Revision: #2 $
//
// $Change: 1061132 $
//
// Copyright 1997-2010 Adobe Systems Incorporated. All rights reserved.
//
// NOTICE: Adobe permits you to use, modify, and distribute this file in accordance
// with the terms of the Adobe license agreement accompanying it. If you have received
// this file from a source other than Adobe, then your use, modification, or
// distribution of it requires the prior written permission of Adobe.
//
//========================================================================================
#include "IDFactory.h"
#include "IObjectModel.h"
#include "ISession.h"
#ifdef REGISTER_OM_IDS
IDFactory* IDFactory::fgFirstID = nil;
IDFactory::IDFactory(const int32& space, const char* name, const int32& id) :
fNextID(fgFirstID),
fSpace(space),
fName(name),
fId(id)
{
fgFirstID = this;
}
void IDFactory::InstallIDs(PluginID ownerComponent)
{
InterfacePtr<IObjectModel> om(GetExecutionContextSession(), IID_IOBJECTMODEL);
for (IDFactory *idFactory = fgFirstID; idFactory != nil; idFactory = idFactory->fNextID)
om->RegisterID(ownerComponent, idFactory->fSpace, idFactory->fName, idFactory->fId);
// Transmit an invalid ID at the end, so that the object model will know that all
// IDs for this plug-in have been registered.
om->RegisterID(kInvalidPlugin, kPlugInIDSpace, nullptr, kInvalidPlugin.Get()) ;
}
#endif // REGISTER_OM_IDS
| [
"[email protected]"
] | |
3daf6fbd97112791ad06b844765f54d34e695c50 | e65df504fa21f9cb232f68dbd020b24a7ce3268e | /src/Applications/Capsid/asphVsFVKcont.cc | c067a7764c4162035967d167f7f12258c91a28bf | [
"MIT"
] | permissive | zhili93/voom | bdbbc56e9a8f49603747c329b72dbf9200912d6b | 856b3109dde60f76e4bf32c914ca5916bebd00c8 | refs/heads/master | 2020-12-03T10:29:19.488974 | 2016-05-10T18:12:33 | 2016-05-10T18:12:33 | 58,485,720 | 0 | 1 | null | 2016-05-10T18:49:51 | 2016-05-10T18:49:51 | null | UTF-8 | C++ | false | false | 9,851 | cc | #include <string>
#include <iostream>
#include <time.h>
#include <vector>
#include <fstream>
#include <unistd.h>
#include <tvmet/Vector.h>
#include "Node.h"
#include "FVK.h"
#include "LoopShellBody.h"
#include "Model.h"
#include "Lbfgsb.h"
#include <vtkDataSet.h>
#include <vtkPointData.h>
#include <vtkPolyData.h>
#include <vtkDataSetReader.h>
#include <vtkPolyDataWriter.h>
#include <vtkPolyDataNormals.h>
#include <vtkSmartPointer.h>
#include <vtkUnstructuredGrid.h>
#include <vtkGeometryFilter.h>
#include <vtkSetGet.h>
#include <vtkExtractEdges.h>
#include <vtkCellArray.h>
#include <vtkIdList.h>
#include <vtkUnsignedIntArray.h>
#include <vtkCell.h>
#include "LennardJones.h"
#include "PotentialBody.h"
#include "Utils/PrintingProtein.h"
#if defined(_OPENMP)
#include <omp.h>
#endif
using namespace tvmet;
using namespace std;
using namespace voom;
int main(int argc, char* argv[])
{
clock_t t1,t2;
t1=clock();
if ( argc != 2 ){
cout<<"usage: "<< argv[0] <<" <filename>\n";
return -1;
}
bool remesh = true;
string prestressFlag = "yes";
string inputFileName = argv[1];
vtkDataSetReader * reader = vtkDataSetReader::New();
reader->SetFileName( inputFileName.c_str() );
//We will use this object, shortly, to ensure consistent triangle
//orientations
vtkPolyDataNormals * normals = vtkPolyDataNormals::New();
//We have to pass a vtkPolyData to vtkPolyDataNormals::SetInput() If
//our input vtk file has vtkUnstructuredGridData instead of
//vtkPolyData then we need to convert it using vtkGeometryFilter
vtkSmartPointer<vtkDataSet> ds = reader->GetOutput();
ds->Update();
if(ds->GetDataObjectType() == VTK_UNSTRUCTURED_GRID){
vtkSmartPointer<vtkUnstructuredGrid> unstructuredGrid =
reader->GetUnstructuredGridOutput();
vtkSmartPointer<vtkGeometryFilter> geometryFilter =
vtkSmartPointer<vtkGeometryFilter>::New();
geometryFilter->SetInput(unstructuredGrid);
geometryFilter->Update();
vtkSmartPointer<vtkPolyData> polydata = geometryFilter->GetOutput();
normals->SetInput( polydata);
}
else{
normals->SetInput(reader->GetOutput());
}
// send through normals filter to ensure that triangle orientations
// are consistent
normals->ConsistencyOn();
normals->SplittingOff();
normals->AutoOrientNormalsOn();
vtkSmartPointer<vtkPolyData> mesh = normals->GetOutput();
mesh->Update();
std::cout << "mesh->GetNumberOfPoints() = " << mesh->GetNumberOfPoints()
<< std::endl;
//Following few lines of code are meant to obtain number of edges
//from the mesh
vtkSmartPointer<vtkExtractEdges> extractedEdges =
vtkSmartPointer<vtkExtractEdges>::New();
extractedEdges->SetInput(mesh);
extractedEdges->Update();
//Uncommenting the next line fetches the line entities, if you want
//them : Amit
//vtkCellArray * lines = extractedEdges()->GetOutput()->GetLines();
//Number of Cells in vtkExtractEdges = number of edges : Amit
std::cout << "Number of edges in the mesh= "
<< extractedEdges->GetOutput()->GetNumberOfCells()
<<std::endl;
// create vector of nodes
double Rcapsid = 1.0;
int dof=0;
std::vector< NodeBase* > nodes;
std::vector< DeformationNode<3>* > defNodes;
double Ravg = 0;
// read in points
for(int a=0; a<mesh->GetNumberOfPoints(); a++) {
int id=a;
DeformationNode<3>::Point x;
mesh->GetPoint(a, &(x[0]));
Ravg += tvmet::norm2(x);
NodeBase::DofIndexMap idx(3);
for(int j=0; j<3; j++) idx[j]=dof++;
DeformationNode<3>* n = new DeformationNode<3>(id,idx,x);
nodes.push_back( n );
defNodes.push_back( n );
}
assert(nodes.size()!=0);
Ravg /= nodes.size();
cout << "Number of nodes: " <<nodes.size() << endl
<< "Ravg = " << Ravg << endl;
// read in triangle connectivities
vector< tvmet::Vector<int,3> > connectivities;
tvmet::Vector<int, 3> c;
int ntri=mesh->GetNumberOfCells();
connectivities.reserve(ntri);
std::cout << "Number of triangles: " <<ntri << endl;
for (int i = 0; i<ntri; i++){
assert(mesh->GetCell(i)->GetNumberOfPoints() == 3);
for(int a=0; a<3; a++) c[a] = mesh->GetCell(i)->GetPointId(a);
connectivities.push_back(c);
}
double C0 = 0.0;
// rescale size
if( prestressFlag == "spherical" ) {
// make capsid spherical
C0 = - 2.0/Rcapsid; // WSK: use minus sign here consistent with
// outward pointing surface normals.
for(int i=0; i<defNodes.size(); i++) {
DeformationNode<3>::Point x;
x = defNodes[i]->point();
double R = norm2(x);
x *= Rcapsid/R;
defNodes[i]->setPoint(x);
defNodes[i]->setPosition(x);
}
}
else {
for(int i=0; i<defNodes.size(); i++) {
DeformationNode<3>::Point x;
x = defNodes[i]->point();
x *= Rcapsid/Ravg;
defNodes[i]->setPoint(x);
defNodes[i]->setPosition(x);
}
}
// We want variable number of FVK increments in different ranges. So
// we will read FVK values from a file instead of generating it by
// code
std::ifstream fvkFile("fvkSteps.dat");
assert(fvkFile);
std::vector<vector<double> > gammaVec;
double currFVK,currPrintFlag;
while(fvkFile>>currFVK>>currPrintFlag){
std::vector<double> currLine;
currLine.push_back(currFVK);
currLine.push_back(currPrintFlag);
gammaVec.push_back(currLine);
}
fvkFile.close();
//Uncomment if you want to calculate FVK values by code
/*
double expMin = .0; // log_10(1) = 0 -> FVK = 1
double expMax = 4.0; // log_10(10000) = 4 -> FVK = 10000
double FVK_steps = 1000;
// Calculate increment to create 1000 evenly spaced exponents from 0
// to 4
double expIncr = (expMax-expMin)/FVK_steps;
double currExponent; // Used to calculate FVK number
*/
// The Young's modulus and bending modulus
double Y;
double KC;
double nu = 1.0/3.0;
double KG;
//Order of quadrature
int quadOrder = 2;
typedef FVK MaterialType;
typedef LoopShellBody<MaterialType> LSB;
typedef LoopShell<MaterialType> LS;
LSB * bd;
// create Model
Model::BodyContainer bdc;
//Parameters for the l-BFGS solver
int m=5;
int maxIter=500;//1000;//model.dof();
double factr=1.0e+1;
double pgtol=1.0e-5;
int iprint = 1;
std::stringstream sstm;
string fname = inputFileName.substr(0,inputFileName.find("."));
string iName;
string rName;
ofstream myfile;
myfile.open ("asphVsFVKcont.dat");
myfile << "Ravg,Y,asphericity,FVK"<< endl;
double asphericity;
Lbfgsb solver(3*nodes.size(), m, factr, pgtol, iprint, maxIter );//(true);
int fileNum=1;
//*************************** FOR_LOOP ***************************//
//Loop over all values of FVK number and relax the shape
for(std::vector<vector<double> >::iterator q=gammaVec.begin();
q!=gammaVec.end();++q){
//Uncomment if you want to calculate FVK values by code
/*
currExponent = expMin + q*expIncr;
gamma = pow(10.0,currExponent);
*/
double gamma = (*q)[0];
double currPrintFlag = (*q)[1];
// Set the Young's modulus and other material properties based on
// current FVK number
Y = sqrt(gamma);
KC = 1.0/Y;
KG = -2.0*(1.0-nu)*KC;
//Remove the bending body from previous iteration and add new
//one
if (!bdc.empty()){
bdc.pop_back();
delete bd;
}
MaterialType bending( KC, KG, C0, Y, nu );
bd = new LSB(bending, connectivities, nodes, quadOrder);
bd->setOutput(paraview);
bdc.push_back(bd);
Model model(bdc,nodes);
if(q==gammaVec.begin()){// We need to do this only once
solver.resize(model.dof());
}
std::cout << "Relaxing shape for gamma = " << gamma << std::endl
<< "Energy = " << solver.function() << std::endl;
for(int n=0; n<nodes.size(); n++) {
for(int i=0; i<nodes[n]->dof(); i++) nodes[n]->setForce(i,0.0);
}
for(int b=0; b<bdc.size(); b++) {
std::cout << "bdc[" << b << "]->compute()" << std::endl;
bdc[b]->compute(true,true,false);
}
std::cout << "Initial Shape." << std::endl
<< "Energy = " << solver.function() << std::endl;
//Uncomment the following region if you want to print initial
//shapes
/*
sstm << fname <<".initial-" << q;
iName = sstm.str();
model.print(iName);
sstm.str("");
sstm.clear(); // Clear state flags.
*/
// relax initial shape
solver.solve(&model);
std::cout << "Shape relaxed." << std::endl
<< "Energy = " << solver.function() << std::endl;
//Uncomment the following region if you want to print relaxed
//shapes
if(currPrintFlag){// Print relaxed shape for selected FVK
sstm << fname <<"-relaxed-" <<fileNum++;
rName = sstm.str();
model.print(rName);
sstm.str("");
sstm.clear(); // Clear state flags
}
// Calculating centre of the sphere as average of position vectors
// of all nodes of the sphere
tvmet::Vector<double,3> Xavg(0.0);
for ( int i = 0; i<defNodes.size(); i++){
Xavg += defNodes[i]->point();
}
Xavg /= nodes.size();
Ravg = 0.0;
for ( int i = 0; i<defNodes.size(); i++){
Ravg += tvmet::norm2( defNodes[i]->point() - Xavg );
}
Ravg /= nodes.size();
double dRavg2 = 0.0;
for ( int i = 0; i<defNodes.size(); i++){
double dR = (tvmet::norm2( defNodes[i]->point() - Xavg) - Ravg);
dRavg2 += dR*dR;
}
dRavg2 /= nodes.size();
asphericity = dRavg2/(Ravg*Ravg);
double gammaCalc = Y*Ravg*Ravg/KC;
myfile <<Ravg<<","<<Y<<","<<asphericity<<","<<gammaCalc<<endl;
}
myfile.close();
t2=clock();
float diff ((float)t2-(float)t1);
std::cout<<"Total execution time: "<<diff/CLOCKS_PER_SEC
<<" seconds"<<std::endl;
}
| [
"[email protected]"
] | |
632c4b861a7e70080bbcfe6ec0d81fe28250d803 | e7e1f0299f67a806b80afd3f09a0247b35ac8ad3 | /CS3505/assign3/utah_set.h | 3211c2ec2d2e1b91442bc2e89774e89e70420d55 | [] | no_license | amozoss/CS3505 | dcb206a59e9dca94472e2c5ddb707d4768fb6d74 | 36509a1b1973688e6c1d0497d3d4a28f97134231 | refs/heads/master | 2020-12-25T19:04:19.258803 | 2013-12-02T17:13:56 | 2013-12-02T17:13:56 | 7,835,210 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,342 | h | /* A 'utah set' is defined as a set of strings stored
* in a hashtable that uses chaining to resolve collisions.
*
* Peter Jensen
* January 17, 2013
*/
#ifndef UTAH_SET_H
#define UTAH_SET_H
#include<string>
namespace cs3505
{
class node; // A forward declaration of the class. We can now
// create pointer variables involving the node class.
class utah_set
{
public:
utah_set(int capacity = 10); // Constructor
utah_set(const utah_set & other); // Copy constructor
~utah_set(); // Destructor
void add (std::string element); // Not const - modifies the object
void remove (std::string element); // Not const - modifies the object
bool contains (std::string element) const; // const - does not change the object
int size () const; // Const - does not change object
void get_elements(std::string *array, int n) const; // This function populates an array of strings with elements from the set.
const utah_set & operator= (const utah_set & rhs); // Modifies this object
private:
int hash (std::string s) const; // Const - does not change this object
void clean (); // Not const - modifies the object
int capacity; // The size of the hashtable
int count; // The number of elements in the set
node** table; // The hashtable, a pointer to a node pointer
// (which will really be an array of node pointers
// Below are a few definitions that I use to make sure I am cleaning
// up memory properly. (Notice that I can switch back to public / private
// as many times as I like.) These are not part of a normal
// hashtable, but they are here because they help with debugging.
// These functions and variables are declared static - they exist in the
// class, but not in any particular object. (The objects can access
// them, of course.)
public:
static long long constructor_count (); // A debugging function for Peter
static long long destructor_count (); // A debugging function for Peter
private:
static long long constructor_calls; // A debugging variable for Peter
static long long destructor_calls; // A debugging variable for Peter
};
}
#endif
| [
"[email protected]"
] | |
04e10ab3f6c44b5d0ee4b396efa9c391ce813858 | 03602b1b1350a4a7500da9625580f96adc48e765 | /src/modelo.interno/window/NormalizadorWindow.cpp | 41ae3d55c5957df0aeaa758726dbddf1ec9eae76 | [] | no_license | fernandobt8/cg | c70e9314619615332f866ddcee935957cec90ee8 | 0fc45d5b0e423d80b4e8878484ed470ab6b14304 | refs/heads/master | 2021-01-22T08:14:22.645410 | 2020-09-21T22:46:04 | 2020-09-21T22:46:04 | 18,000,422 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,632 | cpp | /*
* NormalizadorWindow.cpp
*
* Created on: 14/05/2014
* Author: fernandobt8
*/
#include "NormalizadorWindow.h"
NormalizadorWindow::NormalizadorWindow(Coordenada* windowCenter, Coordenada* vectorUp, Coordenada* VPN) {
this->windowCenter = windowCenter;
this->vectorUp = vectorUp;
this->VPN = VPN;
anguloPlanoXY = Utils::getAnguloPlanoXY(vectorUp);
MatrizRotacao matrizXY(anguloPlanoXY, Rotacao::AROUND_X);
vectorUp->multiplyByMatriz(&matrizXY);
anguloCima = Utils::getAnguloPlanoZY(vectorUp);
MatrizRotacao matrizZY(anguloCima, Rotacao::AROUND_Z);
matrizXY.multiply(&matrizZY);
VPN->multiplyByMatriz(&matrizXY);
anguloFrente = Utils::getAnguloPlanoYZ(VPN);
}
Matriz* NormalizadorWindow::getMatrizNormalizacao(){
Matriz* transOrigem = new MatrizTranslacao(-windowCenter->getX(), -windowCenter->getY(), -windowCenter->getZ());
Matriz* normaAngulo = this->getMatrizNormalizarAngulo();
transOrigem->multiply(normaAngulo);
delete normaAngulo;
return transOrigem;
}
Matriz* NormalizadorWindow::getMatrizDesnormalizacao(){
Matriz* matrizYZ = this->getMatrizDesnormalizarAngulo();
MatrizTranslacao trans(windowCenter->getX(), windowCenter->getY(), windowCenter->getZ());
matrizYZ->multiply(&trans);
return matrizYZ;
}
Matriz* NormalizadorWindow::getMatrizNormalizarAngulo(){
Matriz* matrizXY = new MatrizRotacao(anguloPlanoXY, Rotacao::AROUND_X);
MatrizRotacao matrizZY(anguloCima, Rotacao::AROUND_Z);
MatrizRotacao matrizYZ(anguloFrente, Rotacao::AROUND_Y);
matrizXY->multiply(&matrizZY);
matrizXY->multiply(&matrizYZ);
return matrizXY;
}
Matriz* NormalizadorWindow::getMatrizDesnormalizarAngulo(){
Matriz* matrizYZ = new MatrizRotacao(-anguloFrente, Rotacao::AROUND_Y);
MatrizRotacao matrizZY(-anguloCima, Rotacao::AROUND_Z);
MatrizRotacao matrizXY(-anguloPlanoXY, Rotacao::AROUND_X);
matrizYZ->multiply(&matrizZY);
matrizYZ->multiply(&matrizXY);
return matrizYZ;
}
Matriz* NormalizadorWindow::getMatrizFullNormalizar(Matriz* matriz){
Matriz* matrizNorma = this->getMatrizNormalizacao();
Matriz* matrizDesnorma = this->getMatrizDesnormalizacao();
matrizNorma->multiply(matriz);
matrizNorma->multiply(matrizDesnorma);
delete matrizDesnorma;
return matrizNorma;
}
Matriz* NormalizadorWindow::getMatrizFullNormalizarAngulo(Matriz* matriz){
Matriz* matrizNorma = this->getMatrizNormalizarAngulo();
Matriz* matrizDesnorma = this->getMatrizDesnormalizarAngulo();
matrizNorma->multiply(matriz);
matrizNorma->multiply(matrizDesnorma);
delete matrizDesnorma;
return matrizNorma;
}
NormalizadorWindow::~NormalizadorWindow() {
delete VPN;
delete vectorUp;
delete windowCenter;
}
| [
"[email protected]"
] | |
0c3e4749f6536c2e277298bc6284f346f8b49062 | 3e731150a1a5e5211eae36b163be2505fd55d6b3 | /trabajo/src/materiales-luces.cpp | 1db9a868b3aab5eaa310f32a51e8902302cd7755 | [] | no_license | jesus-lop-puj/IG | 2f19a8d056837fe72e0659685ab9027e7dead9e2 | 2045d97b0763802ab3c03482eb95c5245eb59762 | refs/heads/main | 2023-02-22T05:38:51.779491 | 2021-01-22T10:04:06 | 2021-01-22T10:04:06 | 316,946,154 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 10,426 | cpp | // Nombre: Jesús, Apellidos: López Pujazón, DNI/pasaporte: 26523483K (DDGG IG curso 20-21)
// *********************************************************************
// **
// ** Gestión de materiales y texturas (implementación)
// **
// ** Copyright (C) 2014 Carlos Ureña
// **
// ** This program is free software: you can redistribute it and/or modify
// ** it under the terms of the GNU General Public License as published by
// ** the Free Software Foundation, either version 3 of the License, or
// ** (at your option) any later version.
// **
// ** This program is distributed in the hope that it will be useful,
// ** but WITHOUT ANY WARRANTY; without even the implied warranty of
// ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// ** GNU General Public License for more details.
// **
// ** You should have received a copy of the GNU General Public License
// ** along with this program. If not, see <http://www.gnu.org/licenses/>.
// **
// *********************************************************************
#include "matrices-tr.h"
#include "materiales-luces.h"
using namespace std ;
const bool trazam = false ;
//**********************************************************************
Textura::Textura( const std::string & nombreArchivoJPG )
{
// COMPLETAR: práctica 4: cargar imagen de textura
// (las variables de instancia están inicializadas en la decl. de la clase)
// .....
imagen = LeerArchivoJPEG(nombreArchivoJPG.c_str(), ancho, alto);
}
// ---------------------------------------------------------------------
//----------------------------------------------------------------------
void Textura::enviar()
{
// COMPLETAR: práctica 4: enviar la imagen de textura a la GPU
// y configurar parámetros de la textura (glTexParameter)
// .......
glGenTextures(1, &ident_textura); //Generamos identificador
glActiveTexture(GL_TEXTURE0); //Activamos identificador
glBindTexture(GL_TEXTURE_2D, ident_textura); //Activamos textura con el identificador indicado
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); //Parametros de textura
//Enviamos a la GPU
gluBuild2DMipmaps(GL_TEXTURE_2D,
GL_RGB, //Formato interno
ancho, //Nº de columnas
alto, //Nº de filas
GL_RGB, //formato y orden de los texels en RAM
GL_UNSIGNED_BYTE, //tipo de cada componente de cada texel
imagen //Puntero a ls bytes con texels
);
}
//----------------------------------------------------------------------
Textura::~Textura( )
{
using namespace std ;
cout << "destruyendo textura...imagen ==" << imagen << endl ;
if ( imagen != nullptr )
delete [] imagen ;
imagen = nullptr ;
cout << "hecho (no hecho!)" << endl << flush ;
}
//----------------------------------------------------------------------
// por ahora, se asume la unidad de texturas #0
void Textura::activar( Cauce & cauce )
{
// COMPLETAR: práctica 4: enviar la textura a la GPU (solo la primera vez) y activarla
// .......
if(!enviada){
enviar();
enviada = true;
}
cauce.fijarEvalText(true, ident_textura);
cauce.fijarTipoGCT(modo_gen_ct, coefs_s, coefs_t);
}
// *********************************************************************
// crea un material usando un color plano y los coeficientes de las componentes
Material::Material( const float p_k_amb, const float p_k_dif,
const float p_k_pse, const float p_exp_pse )
{
textura = nullptr ;
k_amb = p_k_amb ;
k_dif = p_k_dif ;
k_pse = p_k_pse ;
exp_pse = p_exp_pse ;
}
//----------------------------------------------------------------------
// crea un material usando una textura y los coeficientes de las componentes
Material::Material( Textura * p_textura, const float p_k_amb, const float p_k_dif,
const float p_k_pse, const float p_exp_pse )
{
textura = p_textura ; assert( textura != nullptr );
k_amb = p_k_amb ;
k_dif = p_k_dif ;
k_pse = p_k_pse ;
exp_pse = p_exp_pse ;
}
//----------------------------------------------------------------------
Material::~Material()
{
if ( textura != nullptr )
{ delete textura ;
textura = nullptr ;
}
}
//----------------------------------------------------------------------
void Material::ponerNombre( const std::string & nuevo_nombre )
{
nombre_mat = nuevo_nombre ;
}
//----------------------------------------------------------------------
std::string Material::nombre() const
{
return nombre_mat ;
}
//----------------------------------------------------------------------
void Material::activar( Cauce & cauce )
{
// COMPLETAR: práctica 4: activar un material
// .....
if(textura != nullptr)
textura->activar(cauce);
else
cauce.fijarEvalText(false);
cauce.fijarParamsMIL({k_amb,k_amb,k_amb}, {k_dif,k_dif,k_dif}, {k_pse,k_pse,k_pse}, exp_pse);
}
//**********************************************************************
FuenteLuz::FuenteLuz( GLfloat p_longi_ini, GLfloat p_lati_ini, const Tupla3f & p_color )
{
//CError();
if ( trazam )
cout << "creando fuente de luz." << endl << flush ;
// inicializar parámetros de la fuente de luz
longi_ini = p_longi_ini ;
lati_ini = p_lati_ini ;
longi = longi_ini ;
lati = lati_ini ;
color = p_color ;
// col_ambiente = p_color ;
// col_difuso = p_color ;
// col_especular = p_color ;
//ind_fuente = -1 ; // la marca como no activable hasta que no se le asigne indice
//CError();
}
//----------------------------------------------------------------------
// para fuentes diraccionales, incrementar o decrementar la longitud
// (en las puntuales no hace nada)
void FuenteLuz::actualizarLongi( const float incre )
{
longi = longi + incre ;
using namespace std ;
cout << "actualizado angulo de 'longitud' de una fuente de luz, nuevo == " << longi << endl ;
}
//----------------------------------------------------------------------
// para fuentes diraccionales, incrementar o decrementar la longitud
// (en las puntuales no hace nada)
void FuenteLuz::actualizarLati( const float incre )
{
lati = lati + incre ;
using namespace std ;
cout << "actualizado angulo de 'latitud' de una fuente de luz, nuevo == " << lati << endl ;
}
//**********************************************************************
ColFuentesLuz::ColFuentesLuz()
{
max_num_fuentes = -1 ;
}
//----------------------------------------------------------------------
void ColFuentesLuz::insertar( FuenteLuz * pf ) // inserta una nueva
{
assert( pf != nullptr );
//pf->ind_fuente = vpf.size() ;
vpf.push_back( pf ) ;
}
//----------------------------------------------------------------------
// activa una colección de fuentes de luz
void ColFuentesLuz::activar( Cauce & cauce )
{
// COMPLETAR: práctica 4: activar una colección de fuentes de luz
// (crear un array con los colores y otro con las posiciones/direcciones,
// usar el cauce para activarlas)
// .....
vector<Tupla3f> colores;
vector<Tupla4f> pos_dir;
for(unsigned int i=0; i<vpf.size(); i++){
colores.push_back(vpf[i]->color);
Tupla4f ejeZ = {0.0,0.0,1.0,0.0};
ejeZ=MAT_Rotacion(vpf[i]->longi, 0.0, 1.0, 0.0) * ejeZ;
ejeZ=MAT_Rotacion(vpf[i]->longi, -1.0, 0.0, 0.0) * ejeZ;
pos_dir.push_back(ejeZ);
}
cauce.fijarFuentesLuz(colores,pos_dir);
}
// ---------------------------------------------------------------------
// pasa a la siguiente fuente de luz (si d==+1, o a la anterior (si d==-1))
// aborta si 'd' no es -1 o +1
void ColFuentesLuz::sigAntFuente( int d )
{
assert( i_fuente_actual < vpf.size()) ;
assert( d == 1 || d== -1 );
i_fuente_actual = unsigned((int(i_fuente_actual+vpf.size())+d) % vpf.size()) ;
cout << "fuente actual: " << (i_fuente_actual+1) << " / " << vpf.size() << endl ;
}
// ---------------------------------------------------------------------
// devuelve un puntero a la fuente de luz actual
FuenteLuz * ColFuentesLuz::fuenteLuzActual()
{
assert( vpf[i_fuente_actual] != nullptr );
return vpf[i_fuente_actual] ;
}
//----------------------------------------------------------------------
ColFuentesLuz::~ColFuentesLuz()
{
for( unsigned i = 0 ; i < vpf.size() ; i++ )
{
assert( vpf[i] != NULL );
delete vpf[i] ;
vpf[i] = NULL ;
}
}
//--------------------------------------------------------------------------
// actualizar una colección de fuentes en función de una tecla GLFW pulsada
// (se usa el código glfw de la tecla, se llama desde 'main.cpp' con L pulsada)
// devuelve 'true' sii se ha actualizado algo
bool ProcesaTeclaFuenteLuz( ColFuentesLuz * col_fuentes, int glfw_key )
{
assert( col_fuentes != nullptr );
FuenteLuz * fuente = col_fuentes->fuenteLuzActual() ; assert( fuente != nullptr );
bool redib = true ;
const float delta_grad = 2.0 ; // incremento en grados para long. y lati.
switch( glfw_key )
{
case GLFW_KEY_RIGHT_BRACKET : // tecla '+' en el teclado normal
case GLFW_KEY_KP_ADD :
col_fuentes->sigAntFuente( +1 );
break ;
case GLFW_KEY_SLASH : // tecla con '-' y '_' en el teclado normal
case GLFW_KEY_KP_SUBTRACT :
col_fuentes->sigAntFuente( -1 );
break ;
case GLFW_KEY_LEFT :
fuente->actualizarLongi( +delta_grad );
break ;
case GLFW_KEY_RIGHT :
fuente->actualizarLongi( -delta_grad );
break ;
case GLFW_KEY_DOWN :
fuente->actualizarLati( -delta_grad );
break ;
case GLFW_KEY_UP :
fuente->actualizarLati( +delta_grad );
break ;
default :
redib = false ;
break ;
}
return redib ;
}
//-----------------------------------------------------------------------
// constructor de una colección de fuentes de luz sencilla que incluye
// dos fuentes de luz.
Col2Fuentes::Col2Fuentes()
{
const float f0 = 0.7, f1 = 0.3 ;
insertar( new FuenteLuz( +45.0, 60.0, Tupla3f { f0, f0, f0, } ) );
insertar( new FuenteLuz( -70.0, -30.0, Tupla3f { f1, f1*0.5, f1*0.5 } ) );
}
| [
"[email protected]"
] | |
1dbbce0b5880e6476f84bc236d201cdc5dfabc10 | e78ba99ec1479ebf6327e64b59fdc13f38fa08b7 | /src/font/latin1/robotocondensed_regular_16_latin1.cpp | e8befcc7f0d42ab8b1125789df90c680624f40e1 | [
"MIT"
] | permissive | Dannyboy001/openHASP | ff490058a74931689ef12b77cf1fccf35057219a | 0548367982869445b173e7bcb3f5b08de8055220 | refs/heads/master | 2023-09-05T08:28:22.331987 | 2021-11-22T19:04:42 | 2021-11-22T19:04:42 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 112,039 | cpp | /* clang-format off */
/*******************************************************************************
* Size: 16 px
* Bpp: 3
* Opts: --no-kerning --bpp 3 --size 16 --font src/font/roboto/RobotoCondensed-Regular.ttf -r 0x20-0x7E,0xA0,0xA1,0xA3,0xB0,0xB1,0xB2,0xB3,0xB5,0xBF,0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF,0xD0,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,0xD7,0xD8,0xD9,0xDA,0xDB,0xDC,0xDD,0xDE,0xDF,0xE0,0xE1,0xE2,0xE3,0xE4,0xE5,0xE6,0xE7,0xE8,0xE9,0xEA,0xEB,0xEC,0xED,0xEE,0xEF,0xF0,0xF1,0xF2,0xF3,0xF4,0xF5,0xF6,0xF7,0xF8,0xF9,0xFA,0xFB,0xFC,0xFD,0xFE,0xFF,0x011E-0x011F,0x0130,0x0131,0x0152-0x0153,0x015E-0x015F,0x0160-0x0161,0x017D-0x017E,0x1E9E,0x2022,0x20AC --font src/font/MaterialDesign-Webfont/materialdesignicons-webfont.ttf -r 0xF0004,0xF001B,0xF0026,0xF0045,0xF004D,0xF0054,0xF005D,0xF008E,0xF009A,0xF00AC,0xF00AF,0xF00ED,0xF010B,0xF011C,0xF012C,0xF0140,0xF0141,0xF0142,0xF0143,0xF0150,0xF0156,0xF0176,0xF01D9,0xF01FA,0xF0210,0xF0238,0xF028F,0xF02DA,0xF02DC,0xF02E3,0xF030B,0xF0322,0xF032A,0xF0335,0xF033E,0xF0374,0xF03E4,0xF040A,0xF0415,0xF0425,0xF0438,0xF0456,0xF0457,0xF0458,0xF0493,0xF049D,0xF049E,0xF04AD,0xF04AE,0xF04B9,0xF04C3,0xF04DB,0xF04DE,0xF0502,0xF050F,0xF051B,0xF0565,0xF057E,0xF0580,0xF058C,0xF058E,0xF058F,0xF0590,0xF0591,0xF0592,0xF0593,0xF0594,0xF0595,0xF0596,0xF0597,0xF0598,0xF0599,0xF059D,0xF059E,0xF05A8,0xF05A9,0xF05F1,0xF05FA,0xF0606,0xF060C,0xF064A,0xF067E,0xF067F,0xF068A,0xF06A1,0xF06A5,0xF06B5,0xF06C0,0xF06C3,0xF06E8,0xF070D,0xF070E,0xF0717,0xF072A,0xF075A,0xF075F,0xF0769,0xF07AE,0xF081B,0xF081C,0xF08DD,0xF0917,0xF091C,0xF0957,0xF095F,0xF096B,0xF099D,0xF09A0,0xF09AB,0xF0A70,0xF0A7A,0xF0AAC,0xF0AD7,0xF0C99,0xF0F5F,0xF0FC6,0xF1011,0xF1020,0xF1054,0xF10AF,0xF111C,0xF111D,0xF111E,0xF11DB,0xF11E1,0xF11F3,0xF12A1,0xF12A2,0xF12A3,0xF12BA,0xF12D3,0xF12D4,0xF139D,0xF140B --format bin -o src/font/latin1/robotocondensed_regular_16_latin1.cpp --format lvgl
******************************************************************************/
#ifdef LV_LVGL_H_INCLUDE_SIMPLE
#include "lvgl.h"
#else
#include "lvgl/lvgl.h"
#endif
#ifndef ROBOTOCONDENSED_REGULAR_16_LATIN1
#define ROBOTOCONDENSED_REGULAR_16_LATIN1 0 // default to off
#endif
#if ROBOTOCONDENSED_REGULAR_16_LATIN1
/*-----------------
* BITMAPS
*----------------*/
/*Store the image of the glyphs*/
static LV_ATTRIBUTE_LARGE_CONST const uint8_t glyph_bitmap[] = {
/* U+0020 " " */
/* U+0021 "!" */
0xb4, 0x7, 0xff, 0x4, 0xfc, 0x91, 0xb7, 0xe0,
/* U+0022 "\"" */
0xe7, 0x20, 0x26, 0x8, 0x1c, 0x78, 0xc0,
/* U+0023 "#" */
0x0, 0x78, 0x90, 0x4, 0xd0, 0x38, 0xb, 0x10,
0x98, 0x7d, 0xb7, 0x19, 0x3c, 0x2d, 0x1c, 0x81,
0x8, 0x32, 0x0, 0x90, 0xc4, 0x7, 0xc7, 0xb6,
0xc3, 0x36, 0xc6, 0xf0, 0x4b, 0x92, 0x44, 0x3,
0x20, 0x78, 0xb2, 0x40, 0x40,
/* U+0024 "$" */
0x3, 0xfe, 0x74, 0xf, 0x70, 0x3d, 0x9a, 0xc0,
0x50, 0xec, 0x30, 0x1, 0x44, 0x9a, 0x2, 0x60,
0x2c, 0x1, 0xcc, 0x5, 0x0, 0x51, 0xf6, 0x6,
0x7d, 0xc8, 0x3, 0xa3, 0x60, 0x1d, 0x0, 0xc0,
0x47, 0x80, 0xe4, 0x4, 0x5f, 0x94, 0x0, 0xba,
0x4e, 0x80, 0xc4, 0x80, 0x80,
/* U+0025 "%" */
0xf, 0xe2, 0x7, 0xa6, 0xb0, 0x2, 0x0, 0x4c,
0x98, 0x84, 0x1, 0x32, 0x65, 0x30, 0x29, 0xac,
0x8a, 0x6, 0x7f, 0x6, 0xc0, 0x7d, 0x2d, 0x78,
0x6, 0x2c, 0xbe, 0xc8, 0x14, 0x8d, 0x42, 0x40,
0x5, 0xa0, 0x3e, 0x70, 0x6a, 0x12, 0x0, 0x48,
0x13, 0xec, 0x80,
/* U+0026 "&" */
0x0, 0xff, 0x30, 0x31, 0x93, 0x10, 0x24, 0x1b,
0x6, 0x4, 0x41, 0x20, 0xc0, 0x91, 0xf9, 0x90,
0x32, 0x2e, 0x1, 0x93, 0x4c, 0x18, 0x2, 0xba,
0x2a, 0x40, 0x45, 0x15, 0x56, 0x8, 0x61, 0x21,
0xe0, 0x15, 0x4d, 0xe, 0x2, 0xab, 0x1c, 0x48,
/* U+0027 "'" */
0x3c, 0xe, 0x20,
/* U+0028 "(" */
0x3, 0xd1, 0x84, 0xd8, 0x48, 0x4, 0x98, 0xa4,
0x1, 0x40, 0x17, 0x3, 0xff, 0x84, 0x78, 0x4,
0x40, 0x64, 0x1, 0x2, 0x1, 0xc0, 0x11, 0xa0,
0x1c, 0x0,
/* U+0029 ")" */
0x3, 0x9c, 0x2, 0x69, 0x0, 0xac, 0x2, 0x64,
0x80, 0x8d, 0x2, 0x48, 0x5, 0xc8, 0x1f, 0x88,
0x18, 0x81, 0xc4, 0xb, 0x30, 0x27, 0x80, 0x12,
0x60, 0x23, 0x0, 0x9c, 0x2, 0xe0, 0x40,
/* U+002A "*" */
0x2, 0xe0, 0x7f, 0xa5, 0x61, 0x57, 0x4c, 0x14,
0xa3, 0x8, 0x50, 0x88, 0x3a, 0x40, 0x1f, 0x84,
0x20,
/* U+002B "+" */
0x2, 0x6c, 0x7, 0xb6, 0x1, 0xff, 0xc7, 0x5f,
0x92, 0x7e, 0x2a, 0xd1, 0x2b, 0x44, 0x24, 0x6c,
0x90, 0xf, 0xfe, 0x28,
/* U+002C "," */
0x1d, 0x81, 0x20, 0xb3, 0x32, 0x0,
/* U+002D "-" */
0x3, 0x5f, 0xd2, 0x36, 0x40,
/* U+002E "." */
0x90, 0x48,
/* U+002F "/" */
0x3, 0x74, 0x4, 0x42, 0x2, 0xa8, 0xc, 0xb8,
0x11, 0x24, 0x4, 0x90, 0xd, 0x70, 0x18, 0xb0,
0x24, 0x40, 0xde, 0x81, 0x92, 0x1, 0x20, 0x40,
0xb3, 0x3, 0x0,
/* U+0030 "0" */
0x1, 0x3f, 0x30, 0xd, 0xa4, 0x90, 0xad, 0xcb,
0x83, 0x80, 0x64, 0x7, 0xff, 0x60, 0xe0, 0x19,
0xa, 0xdc, 0xb8, 0x6d, 0x24, 0x80,
/* U+0031 "1" */
0x0, 0xf0, 0x7e, 0x11, 0xe4, 0x0, 0x8c, 0x81,
0xff, 0xde,
/* U+0032 "2" */
0x1, 0x7f, 0x40, 0x2a, 0xec, 0x6c, 0x1, 0x44,
0xd5, 0x5, 0x20, 0x2, 0x0, 0xd0, 0x24, 0x80,
0x71, 0x2a, 0x7, 0x76, 0x40, 0xd0, 0xc0, 0x32,
0x78, 0xe, 0xac, 0x81, 0xb0, 0xa4, 0xc0, 0x8,
0xdb, 0x20,
/* U+0033 "3" */
0x1, 0x7f, 0x30, 0x15, 0xd9, 0x8, 0x28, 0x99,
0xc3, 0xa0, 0xc, 0x81, 0x92, 0x70, 0xb, 0xd4,
0x80, 0x16, 0x89, 0x0, 0x8b, 0x5c, 0x30, 0x22,
0xc4, 0x40, 0xb, 0xa, 0x26, 0xb8, 0xae, 0xd4,
0x40,
/* U+0034 "4" */
0x3, 0x4e, 0x40, 0xe6, 0x7, 0xa1, 0x3, 0xce,
0x81, 0xd1, 0x20, 0x1c, 0xe0, 0x1d, 0x11, 0x3,
0x17, 0xc0, 0xea, 0x2f, 0xc3, 0x39, 0xb5, 0x5,
0x60, 0x99, 0x6, 0x7, 0xf0,
/* U+0035 "5" */
0x1f, 0xf0, 0x22, 0x4a, 0x81, 0x37, 0x20, 0xc0,
0xf1, 0x1b, 0xe0, 0x35, 0x86, 0x87, 0xdb, 0x44,
0x7, 0x20, 0x51, 0x3, 0xbc, 0x0, 0x81, 0xe9,
0xa8, 0xc2, 0x91, 0x54, 0x0,
/* U+0036 "6" */
0x1, 0x35, 0x2, 0xae, 0xc0, 0x9, 0x33, 0x20,
0x32, 0x20, 0x64, 0x37, 0xa0, 0xa, 0xb4, 0xa0,
0x6, 0xc9, 0xb0, 0xe, 0x3, 0x1, 0x70, 0x39,
0x20, 0x2, 0x2, 0x18, 0xa4, 0x3, 0x1d, 0x6c,
0x0,
/* U+0037 "7" */
0x5f, 0xf8, 0xad, 0xb3, 0x4, 0x13, 0xcc, 0xf,
0x2c, 0x7, 0x30, 0x80, 0xea, 0xc0, 0xe2, 0x54,
0xe, 0xa4, 0x80, 0xe6, 0x80, 0xe4, 0x28, 0x1d,
0xc9, 0x1, 0xca, 0x81, 0x80,
/* U+0038 "8" */
0x1, 0x3f, 0x40, 0x11, 0xc8, 0x6c, 0x13, 0x72,
0xc0, 0x7e, 0x4c, 0x92, 0xc2, 0x1d, 0x89, 0x86,
0x6c, 0x48, 0x24, 0x26, 0xd0, 0x1, 0x1, 0xc8,
0x2, 0x3, 0x90, 0xe2, 0x6d, 0x44, 0x76, 0x36,
/* U+0039 "9" */
0x1, 0x7e, 0x40, 0x22, 0xae, 0x90, 0xe2, 0xa2,
0x80, 0x40, 0x12, 0x10, 0x31, 0x4, 0x20, 0x4,
0x2, 0xa5, 0x20, 0x8, 0x75, 0x2c, 0x1f, 0xb8,
0x20, 0x44, 0xd4, 0x2, 0x79, 0x10, 0x12, 0xca,
0x0,
/* U+003A ":" */
0xb4, 0x4a, 0x40, 0x1f, 0xa4, 0x12,
/* U+003B ";" */
0x1d, 0x84, 0x45, 0x40, 0x7f, 0xf0, 0x62, 0xf,
0x0, 0xcc, 0x27, 0x80,
/* U+003C "<" */
0x3, 0x1a, 0x5, 0x33, 0xf, 0xb9, 0x94, 0x7d,
0x86, 0x5b, 0x0, 0x3a, 0x47, 0x60, 0x1f, 0x70,
0xd, 0x30,
/* U+003D "=" */
0x3, 0xdb, 0xfd, 0x7d, 0xba, 0x14, 0xb1, 0xdf,
0xeb, 0xed, 0xd0,
/* U+003E ">" */
0xa4, 0xc, 0xf5, 0x20, 0x35, 0x7a, 0x0, 0x5a,
0xba, 0x1, 0xd1, 0xdf, 0x8f, 0xa8, 0xfc, 0x1,
0xa0, 0x18,
/* U+003F "?" */
0xb, 0x7a, 0x5, 0x5d, 0x74, 0x21, 0x55, 0x41,
0x70, 0x4, 0xf, 0x72, 0x6, 0x6b, 0x81, 0xa4,
0x10, 0x26, 0x18, 0x18, 0xb0, 0x39, 0x40, 0x39,
0x40, 0x38, 0xa0, 0x20,
/* U+0040 "@" */
0x3, 0x4d, 0xf4, 0x3, 0xd8, 0xff, 0x1c, 0x6,
0xaa, 0x90, 0x6a, 0x60, 0xb, 0x81, 0xfa, 0x64,
0x0, 0xb4, 0x15, 0xc1, 0x4, 0x42, 0x41, 0xe9,
0x2, 0x28, 0x12, 0x9, 0x86, 0x47, 0x3, 0x10,
0x3f, 0xe6, 0x4, 0x58, 0xe4, 0x9, 0x81, 0xe2,
0xc1, 0x30, 0x30, 0x34, 0xc8, 0x54, 0x3c, 0x2d,
0x4e, 0x2, 0xb3, 0x3c, 0x5f, 0x10, 0x6, 0x64,
0x1, 0x10, 0x39, 0xd9, 0xfc, 0x6,
/* U+0041 "A" */
0x2, 0x3d, 0x81, 0xe4, 0x30, 0x1e, 0xa5, 0x1,
0xe3, 0x2, 0x3, 0x20, 0x8e, 0x3, 0x74, 0x2b,
0x3, 0x2c, 0x10, 0x20, 0x10, 0x40, 0x8a, 0x3,
0xd, 0xf8, 0x20, 0xd, 0x6d, 0x42, 0x61, 0xc9,
0x98, 0x54, 0x20, 0x32, 0xa0,
/* U+0042 "B" */
0xdf, 0xd9, 0x80, 0x36, 0x9c, 0x21, 0xa4, 0xa2,
0x81, 0xff, 0x31, 0x42, 0xfd, 0x19, 0xb, 0x64,
0x68, 0x1, 0x26, 0x78, 0x1c, 0xd8, 0xe, 0x6c,
0x1a, 0x48, 0x78, 0x36, 0x94, 0x40,
/* U+0043 "C" */
0x0, 0x77, 0xe8, 0x4, 0x70, 0xb1, 0xd0, 0x14,
0x64, 0xe2, 0x0, 0xd8, 0x9, 0x4, 0x3, 0x81,
0x1e, 0x80, 0xff, 0xe8, 0x1e, 0x4, 0x79, 0x9,
0x0, 0x90, 0x22, 0x1a, 0x9c, 0x40, 0x59, 0xd8,
0xe8,
/* U+0044 "D" */
0xdf, 0xd4, 0x81, 0x1b, 0x1e, 0x20, 0x1a, 0x78,
0xc0, 0x3d, 0x50, 0x1e, 0x20, 0x7f, 0x10, 0x3f,
0xf8, 0x64, 0xe, 0x20, 0x7d, 0x50, 0x6, 0x9e,
0x30, 0x1, 0xb1, 0xe2, 0x0,
/* U+0045 "E" */
0xdf, 0xf2, 0x6, 0xdc, 0x83, 0x4b, 0x1, 0xff,
0xc4, 0x5f, 0xd4, 0x2, 0xda, 0x80, 0x44, 0xe0,
0x3f, 0xf8, 0x8d, 0x2c, 0x0, 0xdb, 0x90,
/* U+0046 "F" */
0xdf, 0xf1, 0x6, 0xdc, 0x43, 0x4b, 0x1, 0xff,
0xcb, 0x5f, 0xd0, 0x2, 0xda, 0x80, 0x44, 0xc0,
0x7f, 0xf2, 0xc0,
/* U+0047 "G" */
0x0, 0xb7, 0xe8, 0x4, 0x6b, 0xb1, 0xd0, 0x10,
0xd4, 0xea, 0x21, 0x20, 0x12, 0x60, 0x5c, 0xd,
0x8, 0x1f, 0xfc, 0x13, 0xfc, 0x80, 0xc7, 0x50,
0x37, 0x0, 0x50, 0x12, 0x60, 0x7d, 0x6, 0x6a,
0x86, 0xe, 0x72, 0xbc, 0x40,
/* U+0048 "H" */
0xd4, 0xd, 0xa8, 0x1f, 0xfd, 0x55, 0xfe, 0x20,
0x16, 0xd8, 0x81, 0x13, 0x80, 0xff, 0xeb, 0x0,
/* U+0049 "I" */
0xb4, 0x7, 0xff, 0x28,
/* U+004A "J" */
0x3, 0xb4, 0x3, 0xff, 0xca, 0x58, 0x1c, 0xa0,
0x11, 0xec, 0x55, 0x43, 0x15, 0xd7, 0x80,
/* U+004B "K" */
0xd4, 0xa, 0xf0, 0x39, 0x25, 0x3, 0xaa, 0x40,
0x35, 0x14, 0xc, 0xd6, 0x3, 0x38, 0x48, 0xc,
0x4c, 0xc0, 0xec, 0xa0, 0x19, 0xa, 0x20, 0x1e,
0x8c, 0x81, 0xcc, 0x70, 0x3d, 0x4b,
/* U+004C "L" */
0xd4, 0xf, 0xff, 0xcb, 0x4b, 0x0, 0x36, 0xe2,
/* U+004D "M" */
0xdc, 0x81, 0x8f, 0xc0, 0x28, 0x19, 0x1, 0x90,
0x1a, 0x81, 0x13, 0x1, 0x12, 0x0, 0x82, 0x0,
0x82, 0x2, 0x74, 0x7, 0x40, 0x47, 0x10, 0xb,
0x81, 0x90, 0x68, 0x20, 0x39, 0xec, 0x40, 0x7b,
0x27, 0x80, 0xf2, 0x0, 0xc0, 0xf9, 0x10, 0x30,
/* U+004E "N" */
0xdc, 0xd, 0xa8, 0x6, 0x7, 0xd0, 0xf, 0x20,
0xc0, 0xf4, 0xa0, 0x79, 0x96, 0x7, 0xa5, 0x3,
0xcc, 0xa0, 0x3c, 0xe0, 0x1e, 0x84, 0x80, 0xf3,
0x3, 0xe8, 0x0,
/* U+004F "O" */
0x0, 0x77, 0xe8, 0x4, 0x70, 0x90, 0xe8, 0x8,
0x73, 0x6a, 0x88, 0x48, 0x4, 0x82, 0x1, 0xc0,
0xc7, 0x81, 0xf8, 0x81, 0xff, 0xc5, 0x20, 0x38,
0x18, 0xf0, 0x90, 0x9, 0x4, 0x21, 0xcd, 0xaa,
0x20, 0xe1, 0x21, 0xd0,
/* U+0050 "P" */
0xdf, 0xe8, 0x4, 0x6d, 0x47, 0x40, 0x34, 0x8e,
0x20, 0x3c, 0x81, 0x3, 0x98, 0x1e, 0x30, 0x90,
0x5f, 0xb0, 0xe0, 0x16, 0xd8, 0x81, 0x13, 0x1,
0xff, 0xcf,
/* U+0051 "Q" */
0x0, 0x77, 0xe8, 0x4, 0x70, 0x8d, 0xa8, 0x8,
0x73, 0x95, 0x10, 0xa8, 0x12, 0x8, 0x1, 0x3,
0xb8, 0x1f, 0x10, 0x3f, 0xf8, 0xa4, 0x8, 0x81,
0xdc, 0x2a, 0x4, 0x82, 0x10, 0xe6, 0xd5, 0x10,
0x68, 0x90, 0x38, 0x12, 0xdf, 0x95, 0x40, 0x7a,
0xb6,
/* U+0052 "R" */
0xdf, 0xd9, 0x1, 0x1b, 0x4e, 0xa0, 0xd, 0x25,
0x3c, 0xf, 0x36, 0x3, 0xcd, 0x80, 0xe6, 0x70,
0x5, 0xfa, 0x36, 0x0, 0xb5, 0x18, 0xc, 0x51,
0xe0, 0x7a, 0x22, 0x7, 0x21, 0x40, 0xf3, 0x60,
/* U+0053 "S" */
0x1, 0x37, 0xc4, 0x4, 0x76, 0x9e, 0x0, 0xdc,
0xa8, 0x60, 0x38, 0x14, 0x21, 0x42, 0x1, 0xa1,
0x4e, 0xa8, 0xd, 0xab, 0xb4, 0x6, 0x5a, 0x24,
0x30, 0x9, 0x9c, 0x1a, 0x2, 0x20, 0xaa, 0xd5,
0x14, 0x57, 0x2b, 0xa4,
/* U+0054 "T" */
0x9f, 0xfd, 0x6c, 0x85, 0xb1, 0x48, 0x42, 0x50,
0x1f, 0xff, 0xc0,
/* U+0055 "U" */
0xec, 0x9, 0xf0, 0x3f, 0xfe, 0xa7, 0x1, 0x70,
0x15, 0x45, 0x1c, 0xe, 0x2a, 0xa3, 0x0,
/* U+0056 "V" */
0x9c, 0xe, 0xf2, 0x84, 0x4, 0x85, 0x23, 0x1,
0x60, 0x42, 0x40, 0x24, 0x80, 0x39, 0x2, 0x3c,
0x2, 0x8, 0x30, 0x80, 0x97, 0x19, 0x1, 0xb2,
0xb, 0x1, 0x90, 0x41, 0x1, 0x89, 0x42, 0x40,
0x72, 0x28, 0xf, 0x61, 0x80, 0x80,
/* U+0057 "W" */
0x5c, 0xa, 0x70, 0x2b, 0x4c, 0x10, 0x4, 0xc,
0xb1, 0x8, 0x2, 0x8, 0x8, 0x83, 0xc1, 0xb,
0x4, 0x10, 0x48, 0x11, 0xc4, 0x10, 0x2e, 0x47,
0x4a, 0x1d, 0x0, 0x40, 0x16, 0x20, 0xa2, 0x0,
0x84, 0x58, 0x28, 0xe0, 0x23, 0xc1, 0xb, 0x6,
0x4, 0xd2, 0x0, 0xc8, 0x10, 0x2c, 0x30, 0x4,
0x8, 0x18, 0x84, 0x6, 0x40, 0x0,
/* U+0058 "X" */
0x3e, 0x1, 0x5e, 0xa, 0x60, 0xa, 0x60, 0x20,
0x62, 0x88, 0x0, 0xa8, 0x1b, 0x1, 0xa0, 0xc2,
0x1, 0x8a, 0x2c, 0xf, 0xfe, 0x11, 0x45, 0x81,
0xd0, 0xe1, 0x0, 0x8a, 0xa1, 0xb0, 0x14, 0xc,
0x41, 0x1, 0x50, 0x9, 0xb0,
/* U+0059 "Y" */
0x9c, 0xd, 0x78, 0xa1, 0x81, 0x28, 0xa, 0xa0,
0x18, 0x60, 0x39, 0x21, 0x50, 0x12, 0x34, 0x94,
0x3, 0x57, 0x9, 0x1, 0x98, 0x50, 0xf, 0x30,
0x80, 0xff, 0xed, 0x80,
/* U+005A "Z" */
0x3f, 0xfa, 0x1b, 0x73, 0x18, 0x25, 0xc5, 0x1,
0x91, 0xe0, 0x74, 0x44, 0xc, 0xcc, 0x3, 0xa3,
0x20, 0x66, 0x20, 0x1d, 0x18, 0x1d, 0x4, 0x3,
0x9a, 0x5c, 0x50, 0x56, 0xe8,
/* U+005B "[" */
0x2, 0xfd, 0x43, 0x83, 0x90, 0x3f, 0xfb, 0x32,
0xec, 0x80,
/* U+005C "\\" */
0x78, 0xc, 0x89, 0x1, 0x12, 0x40, 0x65, 0x40,
0xd4, 0x81, 0x88, 0x60, 0x67, 0x80, 0xd9, 0x1,
0x90, 0x40, 0x65, 0x80, 0xd9, 0x81, 0x98, 0x20,
0x63, 0x40,
/* U+005D "]" */
0x2, 0xdf, 0x74, 0x9, 0x1, 0xff, 0xd9, 0xcc,
0x7d, 0xc0,
/* U+005E "^" */
0x1, 0x60, 0x19, 0x30, 0x24, 0x42, 0x1, 0xd3,
0xc0, 0x15, 0xcc, 0x20, 0x50, 0x20,
/* U+005F "_" */
0x3, 0xed, 0xff, 0x2f, 0xb7, 0x20,
/* U+0060 "`" */
0x30, 0x82, 0x5c, 0x5, 0xc,
/* U+0061 "a" */
0x1, 0x7f, 0x40, 0x15, 0xd8, 0xd0, 0xfc, 0x99,
0xc1, 0x5d, 0xc8, 0x8, 0xe6, 0x20, 0x1c, 0x44,
0xc, 0x40, 0x10, 0x6, 0x2a, 0x5, 0xc5, 0x2c,
0x80,
/* U+0062 "b" */
0xec, 0xf, 0xfe, 0x47, 0xde, 0x81, 0x3b, 0x15,
0x1, 0x1b, 0x44, 0x7, 0x10, 0x40, 0xcc, 0xf,
0x30, 0x3c, 0x41, 0x11, 0xb4, 0x40, 0x25, 0x8a,
0x80,
/* U+0063 "c" */
0x1, 0x7f, 0x40, 0x15, 0xd8, 0xd8, 0x28, 0x9b,
0x62, 0x18, 0x9, 0x0, 0x78, 0x81, 0xf1, 0xc,
0x4, 0xa1, 0x44, 0x8f, 0xa, 0xed, 0x46,
/* U+0064 "d" */
0x3, 0xa6, 0x3, 0xff, 0x89, 0x7e, 0x20, 0x32,
0x95, 0x0, 0x35, 0xb8, 0x10, 0xc0, 0xff, 0xe3,
0x10, 0xc0, 0xe5, 0x53, 0x60, 0x15, 0x5a, 0x60,
/* U+0065 "e" */
0x1, 0x3f, 0x40, 0x15, 0xd8, 0xd0, 0x51, 0x35,
0xc8, 0x40, 0xb, 0x1, 0xbf, 0x30, 0x2b, 0xb5,
0xc8, 0x2, 0x70, 0x55, 0x25, 0x82, 0xbb, 0x42,
0x80,
/* U+0066 "f" */
0x3, 0xe7, 0xf0, 0x8, 0xf8, 0x42, 0x10, 0x39,
0xd1, 0xdb, 0x41, 0x98, 0x20, 0x81, 0xff, 0xd3,
/* U+0067 "g" */
0x1, 0x7e, 0x98, 0x65, 0x2b, 0x0, 0x63, 0x70,
0x21, 0x1, 0xff, 0xc6, 0x21, 0x81, 0xca, 0xb7,
0x0, 0xaa, 0x54, 0x5, 0x7e, 0x2c, 0x38, 0x9b,
0x60, 0x8d, 0x8d, 0x80,
/* U+0068 "h" */
0xec, 0xf, 0xfe, 0x2f, 0xde, 0x80, 0x76, 0x26,
0x1b, 0x8e, 0x1c, 0x3, 0x3, 0xff, 0xa6,
/* U+0069 "i" */
0xaf, 0x16, 0xb4, 0x3, 0xff, 0x88,
/* U+006A "j" */
0x1, 0x90, 0x4, 0xc0, 0x42, 0x3, 0xb0, 0x3f,
0xfb, 0x2c, 0x12, 0x89, 0x0,
/* U+006B "k" */
0xec, 0xf, 0xfe, 0x52, 0xe8, 0xd, 0x52, 0x1,
0x53, 0x40, 0xaa, 0xe0, 0x62, 0x10, 0x19, 0x48,
0x3, 0x66, 0x20, 0x1d, 0x19, 0x3, 0x33, 0xc0,
/* U+006C "l" */
0xd0, 0xf, 0xfe, 0x50,
/* U+006D "m" */
0xf3, 0x7a, 0x6f, 0xc4, 0x2f, 0x56, 0xd0, 0x82,
0x94, 0x85, 0x9a, 0x80, 0xe6, 0x7, 0xff, 0xa8,
/* U+006E "n" */
0xf3, 0x7a, 0x1, 0xca, 0x98, 0x89, 0x58, 0xf,
0xfe, 0xc0,
/* U+006F "o" */
0x1, 0x3f, 0x40, 0x28, 0xe5, 0x70, 0x3, 0x8d,
0x46, 0x8, 0x40, 0x10, 0x20, 0x71, 0xc, 0xe,
0x21, 0x90, 0x80, 0x30, 0x43, 0x89, 0x2b, 0x1,
0x1d, 0xa7, 0x0,
/* U+0070 "p" */
0xf3, 0x7a, 0x4, 0xbd, 0x54, 0x5, 0x2a, 0x20,
0x38, 0x82, 0x6, 0x60, 0x79, 0x81, 0xe2, 0x8,
0x89, 0x22, 0x0, 0xe5, 0x54, 0x7, 0xde, 0x81,
0xff, 0xc4,
/* U+0071 "q" */
0x1, 0x7e, 0x98, 0x65, 0x69, 0x80, 0x31, 0x36,
0x4, 0x20, 0x3f, 0xf8, 0xc4, 0x30, 0x38, 0xd4,
0xd8, 0x6, 0x56, 0x90, 0x15, 0xf8, 0x81, 0xff,
0xc3,
/* U+0072 "r" */
0x3, 0x7b, 0xe0, 0x52, 0x88, 0xc8, 0x1f, 0xfc,
0xc0,
/* U+0073 "s" */
0x1, 0x7e, 0x40, 0x2b, 0xaa, 0x90, 0xaa, 0x88,
0x2, 0x88, 0x52, 0x2b, 0xb9, 0x1, 0x4e, 0xa9,
0x18, 0x88, 0x10, 0xe, 0x98, 0x23, 0xbb, 0x21,
0x0,
/* U+0074 "t" */
0x13, 0x1, 0xf6, 0x67, 0x9e, 0xc6, 0x24, 0x9,
0x1, 0xff, 0xca, 0xe5, 0x80, 0x66, 0x0,
/* U+0075 "u" */
0xec, 0x5, 0xa0, 0x3f, 0xfb, 0xa, 0x28, 0x84,
0x34, 0xa0,
/* U+0076 "v" */
0x9c, 0xb, 0xaa, 0x8, 0x41, 0x10, 0x86, 0x20,
0x16, 0xa, 0x80, 0xe8, 0x14, 0x1, 0x6, 0x8,
0x11, 0xa8, 0xc, 0x8f, 0x3, 0x50, 0x80, 0x0,
/* U+0077 "w" */
0x78, 0x3, 0xc0, 0x1e, 0x24, 0x3, 0x10, 0x19,
0xa0, 0x82, 0x8, 0x2c, 0xe, 0x21, 0xe0, 0x8,
0x22, 0x93, 0x24, 0x4, 0x65, 0xb1, 0x1c, 0x80,
0x20, 0x90, 0x17, 0x80, 0xe2, 0x10, 0x20, 0x49,
0x0, 0x60, 0x80,
/* U+0078 "x" */
0x5d, 0x5, 0xd2, 0xb8, 0xe5, 0x8, 0x95, 0xc0,
0x15, 0x51, 0x2, 0xe3, 0x81, 0xa0, 0x80, 0x48,
0xd2, 0x80, 0x44, 0xa8, 0x11, 0x82, 0x14,
/* U+0079 "y" */
0x9c, 0x1, 0xe7, 0x2, 0x10, 0x28, 0x21, 0x90,
0x5, 0x82, 0xe0, 0x32, 0x21, 0x0, 0x62, 0x10,
0x31, 0x48, 0x6, 0x42, 0x81, 0xb0, 0x20, 0x6c,
0x80, 0xcd, 0xb8, 0x12, 0x8d, 0x1, 0x0,
/* U+007A "z" */
0x3f, 0xf1, 0x2b, 0x64, 0x8, 0x48, 0xd4, 0x3,
0x42, 0xc0, 0x92, 0x70, 0x34, 0x44, 0x9, 0x9a,
0x6, 0x88, 0x98, 0x20, 0xb6, 0x98,
/* U+007B "{" */
0x3, 0x10, 0x7, 0xb0, 0x11, 0x20, 0x5, 0xc0,
0xff, 0xe0, 0x10, 0x35, 0x8, 0x36, 0x80, 0x1a,
0x80, 0x50, 0x10, 0x4, 0x30, 0x3f, 0xf8, 0x27,
0x1, 0x46, 0x80, 0x2c, 0xc0,
/* U+007C "|" */
0xb0, 0xf, 0xfe, 0x70,
/* U+007D "}" */
0x20, 0x65, 0xc0, 0x99, 0x80, 0x55, 0x81, 0xff,
0xc1, 0x20, 0x64, 0x18, 0x14, 0x84, 0x2, 0x34,
0x10, 0x80, 0x8, 0x1f, 0xfc, 0x2c, 0x80, 0x24,
0x80, 0x58, 0x80,
/* U+007E "~" */
0x1, 0xbb, 0x1, 0x58, 0xaa, 0xc8, 0x29, 0x2,
0xaa, 0xbc, 0x88, 0xe4, 0x2f, 0xa8,
/* U+00A0 " " */
/* U+00A1 "¡" */
0xaf, 0x16, 0x9a, 0xd8, 0xc0, 0xff, 0xe0, 0x80,
/* U+00A3 "£" */
0x2, 0xbf, 0x20, 0x2a, 0xeb, 0xa0, 0xa, 0x8a,
0x84, 0x18, 0x60, 0x2b, 0x3, 0xc8, 0x81, 0xf9,
0x51, 0xb9, 0x0, 0xa0, 0x98, 0x81, 0x20, 0x48,
0xc, 0xc3, 0x3, 0xb0, 0x69, 0x44, 0x98, 0xb7,
0x40,
/* U+00B0 "°" */
0x3b, 0xf, 0x91, 0xcb, 0x63, 0x76, 0x55, 0xf9,
0x0,
/* U+00B1 "±" */
0x2, 0xb0, 0xf, 0xfe, 0x21, 0xfc, 0x9f, 0xc7,
0x61, 0x5b, 0x82, 0x4c, 0x98, 0xf, 0xfe, 0x19,
0x29, 0x48, 0xd, 0xba, 0x0,
/* U+00B2 "²" */
0x17, 0xd0, 0x93, 0x36, 0x5c, 0x81, 0x91, 0x60,
0xda, 0x1, 0xda, 0x8, 0xbf, 0x40,
/* U+00B3 "³" */
0x17, 0xd0, 0x86, 0x6c, 0xa9, 0x4, 0x7, 0x8,
0x7, 0x6c, 0xb0, 0x61, 0x3e, 0x18,
/* U+00B5 "µ" */
0xd0, 0x4, 0xc0, 0x7f, 0xf4, 0xc8, 0x1c, 0x91,
0xb0, 0x3, 0x69, 0x80, 0x5f, 0x4c, 0x7, 0xff,
0x0,
/* U+00BF "¿" */
0x0, 0xb8, 0x1c, 0xd8, 0xe, 0x30, 0xe, 0x30,
0xe, 0x4c, 0xe, 0x8c, 0xd, 0x4, 0x2, 0x2e,
0x81, 0x90, 0x40, 0x62, 0x4, 0xb8, 0x42, 0xba,
0x80, 0x57, 0x15, 0x0,
/* U+00C0 "À" */
0x0, 0xfa, 0x3, 0xcd, 0xa0, 0x1f, 0x4a, 0x40,
0xf1, 0x88, 0xf, 0x21, 0x80, 0xf5, 0x28, 0xf,
0x18, 0x10, 0x19, 0x4, 0x70, 0x1b, 0xa1, 0x58,
0x19, 0x60, 0x81, 0x0, 0x82, 0x4, 0x50, 0x18,
0x6f, 0xc1, 0x0, 0x6b, 0x6a, 0x13, 0xe, 0x4c,
0xc2, 0xa1, 0x1, 0x95,
/* U+00C1 "Á" */
0x3, 0xbd, 0x3, 0xd0, 0xd0, 0x3d, 0xf0, 0x1e,
0x31, 0x81, 0xe4, 0x30, 0x1e, 0xa5, 0x1, 0xe3,
0x2, 0x3, 0x20, 0x8e, 0x3, 0x74, 0x2b, 0x3,
0x2c, 0x10, 0x20, 0x10, 0x40, 0x8a, 0x3, 0xd,
0xf8, 0x20, 0xd, 0x6d, 0x42, 0x61, 0xc9, 0x98,
0x54, 0x20, 0x32, 0xa0,
/* U+00C2 "Â" */
0x2, 0x3d, 0x81, 0xef, 0xaa, 0x3, 0xb1, 0xc8,
0xe, 0x3d, 0x81, 0xe4, 0x30, 0x1e, 0xa5, 0x1,
0xe3, 0x2, 0x3, 0x20, 0x8e, 0x3, 0x74, 0x2b,
0x3, 0x2c, 0x10, 0x20, 0x10, 0x40, 0x8a, 0x3,
0xd, 0xf8, 0x20, 0xd, 0x6d, 0x42, 0x61, 0xc9,
0x98, 0x54, 0x20, 0x32, 0xa0,
/* U+00C3 "Ã" */
0x3, 0xfe, 0x3e, 0xe, 0x6, 0xb0, 0x76, 0x6,
0x8e, 0x78, 0x7, 0x1e, 0xc0, 0xf2, 0x18, 0xf,
0x52, 0x80, 0xf1, 0x81, 0x1, 0x90, 0x47, 0x1,
0xba, 0x15, 0x81, 0x96, 0x8, 0x10, 0x8, 0x20,
0x45, 0x1, 0x86, 0xfc, 0x10, 0x6, 0xb6, 0xa1,
0x30, 0xe4, 0xcc, 0x2a, 0x10, 0x19, 0x50,
/* U+00C4 "Ä" */
0x0, 0xd8, 0x18, 0x6, 0xd8, 0x1b, 0x1, 0xad,
0x5, 0xc0, 0xe3, 0xd8, 0x1e, 0x43, 0x1, 0xea,
0x50, 0x1e, 0x30, 0x20, 0x32, 0x8, 0xe0, 0x37,
0x42, 0xb0, 0x32, 0xc1, 0x2, 0x1, 0x4, 0x8,
0xa0, 0x30, 0xdf, 0x82, 0x0, 0xd6, 0xd4, 0x26,
0x1c, 0x99, 0x85, 0x42, 0x3, 0x2a,
/* U+00C5 "Å" */
0x2, 0x56, 0x1, 0xe9, 0x49, 0x1, 0xf1, 0x3,
0xd2, 0x82, 0x7, 0x35, 0xc0, 0xf2, 0x18, 0xf,
0x52, 0x80, 0xf1, 0x81, 0x1, 0x90, 0x47, 0x1,
0xba, 0x15, 0x81, 0x96, 0x8, 0x10, 0x8, 0x20,
0x45, 0x1, 0x86, 0xfc, 0x10, 0x6, 0xb6, 0xa1,
0x30, 0xe4, 0xcc, 0x2a, 0x10, 0x19, 0x50,
/* U+00C6 "Æ" */
0x3, 0xcf, 0xff, 0x10, 0x3d, 0x1, 0xdb, 0x10,
0x39, 0x84, 0xc9, 0xc0, 0x7a, 0x32, 0xc0, 0xfe,
0x62, 0x1, 0xff, 0x54, 0x0, 0xff, 0x50, 0x33,
0x30, 0xb, 0x6a, 0x1, 0xa9, 0x20, 0x22, 0x70,
0x12, 0x25, 0xf9, 0x81, 0xfa, 0x1b, 0x66, 0x7,
0xc8, 0xd4, 0xae, 0x9, 0xe1, 0x3, 0x2, 0x23,
0x6d, 0x0,
/* U+00C7 "Ç" */
0x0, 0x77, 0xe8, 0x4, 0x70, 0xb1, 0xd0, 0x14,
0x64, 0xe2, 0x0, 0xd8, 0x9, 0x4, 0x3, 0x81,
0x1e, 0x80, 0xff, 0xe8, 0x1e, 0x4, 0x79, 0x9,
0x0, 0x90, 0x22, 0x1a, 0x9c, 0x40, 0x59, 0xd8,
0xe8, 0x11, 0xc2, 0x40, 0x1e, 0xd0, 0xf, 0xb3,
0x2,
/* U+00C8 "È" */
0x17, 0x1, 0xd5, 0xd0, 0x3a, 0xd0, 0x16, 0xff,
0x90, 0x36, 0xe4, 0x1a, 0x58, 0xf, 0xfe, 0x22,
0xfe, 0xa0, 0x16, 0xd4, 0x2, 0x27, 0x1, 0xff,
0xc4, 0x69, 0x60, 0x6, 0xdc, 0x80,
/* U+00C9 "É" */
0x2, 0x7c, 0x81, 0x19, 0x88, 0x11, 0xe4, 0x6,
0xff, 0x90, 0x36, 0xe4, 0x1a, 0x58, 0xf, 0xfe,
0x22, 0xfe, 0xa0, 0x16, 0xd4, 0x2, 0x27, 0x1,
0xff, 0xc4, 0x69, 0x60, 0x6, 0xdc, 0x80,
/* U+00CA "Ê" */
0x1, 0x39, 0x2, 0x66, 0xf0, 0x27, 0x56, 0x1,
0xbf, 0xe4, 0xd, 0xb9, 0x6, 0x96, 0x3, 0xff,
0x88, 0xbf, 0xa8, 0x5, 0xb5, 0x0, 0x89, 0xc0,
0x7f, 0xf1, 0x1a, 0x58, 0x1, 0xb7, 0x20,
/* U+00CB "Ë" */
0x14, 0x86, 0xc0, 0xa6, 0x37, 0x7, 0xa1, 0x60,
0xdf, 0xf2, 0x6, 0xdc, 0x83, 0x4b, 0x1, 0xff,
0xc4, 0x5f, 0xd4, 0x2, 0xda, 0x80, 0x44, 0xe0,
0x3f, 0xf8, 0x8d, 0x2c, 0x0, 0xdb, 0x90,
/* U+00CC "Ì" */
0x1a, 0x80, 0xcd, 0x80, 0x66, 0x2, 0xd0, 0x1f,
0xfe, 0x0,
/* U+00CD "Í" */
0x17, 0x6, 0xd8, 0x3c, 0x2, 0xd0, 0x1f, 0xfe,
0x20,
/* U+00CE "Î" */
0x1, 0xb0, 0xa, 0xdc, 0x2, 0xb6, 0xa0, 0x56,
0x80, 0xff, 0xfc, 0x0,
/* U+00CF "Ï" */
0x34, 0x5, 0x2d, 0x0, 0x4a, 0xe0, 0x3b, 0x1,
0x68, 0xf, 0xff, 0xc0,
/* U+00D0 "Ð" */
0x13, 0xfb, 0x20, 0x3a, 0xd3, 0xac, 0xc, 0x92,
0xb8, 0x7, 0xd4, 0x10, 0x3c, 0x43, 0xac, 0x78,
0x4, 0x62, 0x1a, 0x1, 0x89, 0x2, 0x6, 0x20,
0x78, 0x86, 0x7, 0xa8, 0x20, 0x49, 0x2b, 0x80,
0x6b, 0x4e, 0xb0,
/* U+00D1 "Ñ" */
0x3, 0xfd, 0xb0, 0x62, 0x1, 0x3b, 0xc1, 0x0,
0xab, 0xf8, 0x6, 0xe0, 0x6d, 0x40, 0x30, 0x3e,
0x80, 0x79, 0x6, 0x7, 0xa5, 0x3, 0xcc, 0xb0,
0x3d, 0x28, 0x1e, 0x65, 0x1, 0xe7, 0x0, 0xf4,
0x24, 0x7, 0x98, 0x1f, 0x40, 0x0,
/* U+00D2 "Ò" */
0x0, 0x61, 0x3, 0xc5, 0x40, 0x3e, 0xc9, 0x0,
0xfb, 0xa0, 0x38, 0xef, 0xd0, 0x8, 0xe1, 0x21,
0xd0, 0x10, 0xe6, 0xd5, 0x10, 0x90, 0x9, 0x4,
0x3, 0x81, 0x8f, 0x3, 0xf1, 0x3, 0xff, 0x8a,
0x40, 0x70, 0x31, 0xe1, 0x20, 0x12, 0x8, 0x43,
0x9b, 0x54, 0x41, 0xc2, 0x43, 0xa0,
/* U+00D3 "Ó" */
0x3, 0x93, 0x3, 0xea, 0x7, 0xd5, 0xb0, 0x1e,
0xb0, 0xe, 0x3b, 0xf4, 0x2, 0x38, 0x48, 0x74,
0x4, 0x39, 0xb5, 0x44, 0x24, 0x2, 0x41, 0x0,
0xe0, 0x63, 0xc0, 0xfc, 0x40, 0xff, 0xe2, 0x90,
0x1c, 0xc, 0x78, 0x48, 0x4, 0x82, 0x10, 0xe6,
0xd5, 0x10, 0x70, 0x90, 0xe8,
/* U+00D4 "Ô" */
0x3, 0x22, 0x7, 0x94, 0xe0, 0x7a, 0x75, 0x0,
0xec, 0x64, 0x1, 0x8e, 0xfd, 0x0, 0x8e, 0x12,
0x1d, 0x1, 0xe, 0x6d, 0x51, 0x9, 0x0, 0x90,
0x40, 0x38, 0x18, 0xf0, 0x3f, 0x10, 0x3f, 0xf8,
0xa4, 0x7, 0x3, 0x1e, 0x12, 0x1, 0x20, 0x84,
0x39, 0xb5, 0x44, 0x1c, 0x24, 0x3a, 0x0,
/* U+00D5 "Õ" */
0x3, 0xff, 0x81, 0xa8, 0xc0, 0x66, 0xb7, 0x60,
0x67, 0x1f, 0xa0, 0x63, 0xbf, 0x40, 0x23, 0x84,
0x87, 0x40, 0x43, 0x9b, 0x54, 0x42, 0x40, 0x24,
0x10, 0xe, 0x6, 0x3c, 0xf, 0xc4, 0xf, 0xfe,
0x29, 0x1, 0xc0, 0xc7, 0x84, 0x80, 0x48, 0x21,
0xe, 0x6d, 0x51, 0x7, 0x9, 0xe, 0x80,
/* U+00D6 "Ö" */
0x0, 0xa0, 0x8, 0x6, 0x28, 0x16, 0x40, 0x9e,
0x7, 0x90, 0x23, 0xbf, 0x40, 0x23, 0x84, 0x87,
0x40, 0x43, 0x9b, 0x54, 0x42, 0x40, 0x24, 0x10,
0xe, 0x6, 0x3c, 0xf, 0xc4, 0xf, 0xfe, 0x29,
0x1, 0xc0, 0xc7, 0x84, 0x80, 0x48, 0x21, 0xe,
0x6d, 0x51, 0x7, 0x9, 0xe, 0x80,
/* U+00D7 "×" */
0x3, 0xf6, 0x20, 0x2b, 0xf, 0x86, 0x90, 0x53,
0xa4, 0x10, 0x14, 0x93, 0x2, 0x80, 0xa0, 0x14,
0xf7, 0x48, 0x54, 0x42, 0x87, 0x40, 0x33,
/* U+00D8 "Ø" */
0x0, 0x6f, 0xce, 0x40, 0xc, 0xe2, 0x8e, 0x8,
0x33, 0x88, 0x9, 0x30, 0x5, 0x86, 0xf, 0x1,
0x29, 0xe0, 0x8, 0x2d, 0xc4, 0xd, 0x20, 0x30,
0x22, 0x4d, 0x1, 0x8e, 0x90, 0x0, 0xe0, 0x91,
0xa0, 0xc2, 0x10, 0x3, 0x68, 0xc8, 0x45, 0xc8,
0x70, 0xb, 0xdf, 0xd0, 0x0,
/* U+00D9 "Ù" */
0xf, 0x90, 0x39, 0xce, 0x7, 0x9e, 0x3, 0x76,
0x4, 0xf8, 0x1f, 0xff, 0x53, 0x80, 0xb8, 0xa,
0xa2, 0x8e, 0x7, 0x15, 0x51, 0x80,
/* U+00DA "Ú" */
0x2, 0x3d, 0x81, 0xde, 0x30, 0x3b, 0x30, 0x2e,
0xc0, 0x9f, 0x3, 0xff, 0xea, 0x70, 0x17, 0x1,
0x54, 0x51, 0xc0, 0xe2, 0xaa, 0x30,
/* U+00DB "Û" */
0x0, 0xba, 0x3, 0x19, 0xa1, 0x2, 0x38, 0xe2,
0x3, 0xb0, 0x27, 0xc0, 0xff, 0xfa, 0x9c, 0x5,
0xc0, 0x55, 0x14, 0x70, 0x38, 0xaa, 0x8c, 0x0,
/* U+00DC "Ü" */
0x11, 0x5, 0x0, 0x96, 0x5, 0x1, 0x68, 0x1e,
0x1, 0xd8, 0x13, 0xe0, 0x7f, 0xfd, 0x4e, 0x2,
0xe0, 0x2a, 0x8a, 0x38, 0x1c, 0x55, 0x46, 0x0,
/* U+00DD "Ý" */
0x3, 0x2e, 0x80, 0xf5, 0x88, 0xe, 0x31, 0x81,
0x4e, 0xb, 0x17, 0x8a, 0x18, 0x12, 0x80, 0xaa,
0x1, 0x86, 0x3, 0x92, 0x15, 0x1, 0x23, 0x49,
0x40, 0x35, 0x70, 0x90, 0x19, 0x85, 0x0, 0xf3,
0x8, 0xf, 0xfe, 0xd8,
/* U+00DE "Þ" */
0xd0, 0xf, 0xfe, 0x43, 0xfd, 0x90, 0x5, 0xb1,
0xd2, 0x9, 0xa8, 0x40, 0x7f, 0xcc, 0x20, 0xff,
0x48, 0x21, 0x6c, 0xec, 0x1, 0x30, 0x1f, 0xe0,
/* U+00DF "ß" */
0x17, 0xe4, 0x2, 0x2a, 0xa8, 0x4, 0xd4, 0x4,
0x1e, 0x8, 0x1e, 0x88, 0x81, 0x96, 0x3, 0x8d,
0x3, 0xb9, 0xa0, 0x63, 0x53, 0x3, 0x23, 0xc0,
0x22, 0x6e, 0x3, 0x69, 0x30,
/* U+00E0 "à" */
0x1, 0xa8, 0x1d, 0x9b, 0x1, 0xd9, 0x81, 0xaf,
0xe8, 0x2, 0xbb, 0x1a, 0x1f, 0x93, 0x38, 0x2b,
0xb9, 0x1, 0x1c, 0xc4, 0x3, 0x88, 0x81, 0x88,
0x2, 0x0, 0xc5, 0x40, 0xb8, 0xa5, 0x90,
/* U+00E1 "á" */
0x3, 0x5c, 0x6, 0x6d, 0x80, 0xcf, 0x1, 0xaf,
0xe8, 0x2, 0xbb, 0x1a, 0x1f, 0x93, 0x38, 0x2b,
0xb9, 0x1, 0x1c, 0xc4, 0x3, 0x88, 0x81, 0x88,
0x2, 0x0, 0xc5, 0x40, 0xb8, 0xa5, 0x90,
/* U+00E2 "â" */
0x2, 0xd8, 0x6, 0xb6, 0x80, 0x55, 0xb4, 0x2,
0xbf, 0xa0, 0xa, 0xec, 0x68, 0x7e, 0x4c, 0xe0,
0xae, 0xe4, 0x4, 0x73, 0x10, 0xe, 0x22, 0x6,
0x20, 0x8, 0x3, 0x15, 0x2, 0xe2, 0x96, 0x40,
/* U+00E3 "ã" */
0x3, 0xf1, 0xdf, 0xc4, 0x1f, 0xb3, 0x90, 0x4,
0xc0, 0x6b, 0xfa, 0x0, 0xae, 0xc6, 0x87, 0xe4,
0xce, 0xa, 0xee, 0x40, 0x47, 0x31, 0x0, 0xe2,
0x20, 0x62, 0x0, 0x80, 0x31, 0x50, 0x2e, 0x29,
0x64,
/* U+00E4 "ä" */
0xb, 0x80, 0xe8, 0x36, 0x0, 0xd8, 0x18, 0x2,
0x10, 0x17, 0xf4, 0x1, 0x5d, 0x8d, 0xf, 0xc9,
0x9c, 0x15, 0xdc, 0x80, 0x8e, 0x62, 0x1, 0xc4,
0x40, 0xc4, 0x1, 0x0, 0x62, 0xa0, 0x5c, 0x52,
0xc8,
/* U+00E5 "å" */
0x2, 0xb4, 0x6, 0x9f, 0xa0, 0x19, 0x81, 0xd6,
0x78, 0x4, 0x6d, 0x1, 0xaf, 0xe8, 0x2, 0xbb,
0x1a, 0x1f, 0x93, 0x38, 0x2b, 0xb9, 0x1, 0x1c,
0xc4, 0x3, 0x88, 0x81, 0x88, 0x2, 0x0, 0xc5,
0x40, 0xb8, 0xa5, 0x90,
/* U+00E6 "æ" */
0x6, 0xfc, 0x93, 0xf4, 0x2, 0xee, 0xbb, 0x4e,
0xb6, 0x2, 0x8a, 0x85, 0x13, 0xa0, 0x32, 0x2,
0xc0, 0x31, 0x0, 0xb7, 0xe1, 0x3f, 0x50, 0x2a,
0xb6, 0x7, 0xb6, 0x8, 0x42, 0x40, 0x9e, 0xc,
0x45, 0x42, 0x89, 0xd0, 0x63, 0xa3, 0xd5, 0x6b,
0x0,
/* U+00E7 "ç" */
0x1, 0x7f, 0x40, 0x15, 0xd8, 0xd8, 0x28, 0x9b,
0x62, 0x18, 0x9, 0x0, 0x78, 0x81, 0xf1, 0xc,
0x4, 0xa1, 0x44, 0x8f, 0xa, 0xed, 0x46, 0x2,
0x98, 0xc0, 0xde, 0x1, 0xd9, 0x80,
/* U+00E8 "è" */
0x7, 0xc0, 0x31, 0xcd, 0x1, 0x8f, 0x40, 0x69,
0xfa, 0x0, 0xae, 0xc6, 0x82, 0x89, 0xae, 0x42,
0x0, 0x58, 0xd, 0xf9, 0x81, 0x5d, 0xae, 0x40,
0x13, 0x82, 0xa9, 0x2c, 0x15, 0xda, 0x14,
/* U+00E9 "é" */
0x3, 0x6c, 0x3, 0x47, 0x80, 0xd2, 0x81, 0xa7,
0xe8, 0x2, 0xbb, 0x1a, 0xa, 0x26, 0xb9, 0x8,
0x1, 0x60, 0x37, 0xe6, 0x5, 0x76, 0xb9, 0x0,
0x4e, 0xa, 0xa4, 0xb0, 0x57, 0x68, 0x50,
/* U+00EA "ê" */
0x2, 0xd4, 0xd, 0x61, 0x60, 0x55, 0x46, 0x5,
0x3f, 0x40, 0x15, 0xd8, 0xd0, 0x51, 0x35, 0xc8,
0x40, 0xb, 0x1, 0xbf, 0x30, 0x2b, 0xb5, 0xc8,
0x2, 0x70, 0x55, 0x25, 0x82, 0xbb, 0x42, 0x80,
/* U+00EB "ë" */
0xf, 0x3, 0xd0, 0x28, 0x14, 0xc2, 0x80, 0x29,
0x1, 0x3f, 0x40, 0x15, 0xd8, 0xd0, 0x51, 0x35,
0xc8, 0x40, 0xb, 0x1, 0xbf, 0x30, 0x2b, 0xb5,
0xc8, 0x2, 0x70, 0x55, 0x25, 0x82, 0xbb, 0x42,
0x80,
/* U+00EC "ì" */
0x3e, 0x3, 0x92, 0x3, 0x90, 0xd, 0x0, 0xff,
0xea, 0x0,
/* U+00ED "í" */
0x1a, 0x88, 0xe8, 0x94, 0x6, 0x80, 0x7f, 0xf5,
0x80,
/* U+00EE "î" */
0x1, 0xa8, 0xb, 0x33, 0x15, 0x36, 0x1, 0xa0,
0x1f, 0xfd, 0xd0,
/* U+00EF "ï" */
0x78, 0x1e, 0x8a, 0x5, 0xb2, 0x80, 0x21, 0x1,
0xa0, 0x1f, 0xfe, 0x60,
/* U+00F0 "ð" */
0x1, 0x90, 0x1e, 0x76, 0xb2, 0x2, 0xad, 0x34,
0x4, 0x9b, 0x22, 0x4, 0xbc, 0x30, 0xa, 0x7e,
0x8, 0x3, 0x69, 0x40, 0xd5, 0xb2, 0xe0, 0x83,
0x80, 0xff, 0x30, 0x41, 0xc0, 0x30, 0x14, 0x6f,
0x40, 0xa, 0x49, 0xb0,
/* U+00F1 "ñ" */
0x3, 0xed, 0x83, 0x14, 0xef, 0x5, 0x57, 0xf0,
0xf3, 0x7a, 0x1, 0xca, 0x98, 0x89, 0x58, 0xf,
0xfe, 0xc0,
/* U+00F2 "ò" */
0x7, 0xc0, 0x38, 0xe6, 0x80, 0xe3, 0xd0, 0x1d,
0x3f, 0x40, 0x28, 0xe5, 0x70, 0x3, 0x8d, 0x46,
0x8, 0x40, 0x10, 0x20, 0x71, 0xc, 0xe, 0x21,
0x90, 0x80, 0x30, 0x43, 0x89, 0x2b, 0x1, 0x1d,
0xa7, 0x0,
/* U+00F3 "ó" */
0x3, 0x5c, 0x7, 0x36, 0xc0, 0x73, 0xc0, 0x74,
0xfd, 0x0, 0xa3, 0x95, 0xc0, 0xe, 0x35, 0x18,
0x21, 0x0, 0x40, 0x81, 0xc4, 0x30, 0x38, 0x86,
0x42, 0x0, 0xc1, 0xe, 0x24, 0xac, 0x4, 0x76,
0x9c, 0x0,
/* U+00F4 "ô" */
0x2, 0xd8, 0x7, 0x59, 0x60, 0x1a, 0xa7, 0x0,
0xd3, 0xf4, 0x2, 0x8e, 0x57, 0x0, 0x38, 0xd4,
0x60, 0x84, 0x1, 0x2, 0x7, 0x10, 0xc0, 0xe2,
0x19, 0x8, 0x3, 0x4, 0x38, 0x92, 0xb0, 0x11,
0xda, 0x70, 0x0,
/* U+00F5 "õ" */
0x3, 0xf8, 0xff, 0x88, 0x3, 0xb5, 0xc8, 0x11,
0x30, 0x1d, 0x3f, 0x40, 0x28, 0xe5, 0x70, 0x3,
0x8d, 0x46, 0x8, 0x40, 0x10, 0x20, 0x71, 0xc,
0xe, 0x21, 0x90, 0x80, 0x30, 0x43, 0x89, 0x2b,
0x1, 0x1d, 0xa7, 0x0,
/* U+00F6 "ö" */
0xf, 0x80, 0xe8, 0x2, 0x60, 0x13, 0x0, 0x60,
0xa, 0x40, 0xa7, 0xe8, 0x5, 0x1c, 0xae, 0x0,
0x71, 0xa8, 0xc1, 0x8, 0x2, 0x4, 0xe, 0x21,
0x81, 0xc4, 0x32, 0x10, 0x6, 0x8, 0x71, 0x25,
0x60, 0x23, 0xb4, 0xe0,
/* U+00F7 "÷" */
0x2, 0x8c, 0xf, 0x1e, 0x7, 0xac, 0x3, 0xfe,
0x7f, 0xf8, 0xa6, 0xfc, 0x4a, 0x4f, 0x1, 0xa3,
0x3, 0xc7, 0x81, 0x0,
/* U+00F8 "ø" */
0x3, 0x9b, 0x1, 0x4f, 0xd1, 0x0, 0x6d, 0x20,
0x50, 0x12, 0x1f, 0x2c, 0x10, 0x82, 0xe0, 0x81,
0x24, 0x0, 0xc0, 0xa4, 0x0, 0x64, 0x46, 0x10,
0x22, 0x22, 0xe3, 0x0, 0xc3, 0x8e, 0x0, 0x4f,
0xf4, 0x0,
/* U+00F9 "ù" */
0x3e, 0x1, 0x1c, 0x90, 0x8, 0xe4, 0x3, 0xb0,
0x16, 0x80, 0xff, 0xec, 0x28, 0xa2, 0x10, 0xd2,
0x80,
/* U+00FA "ú" */
0x2, 0xd4, 0xa, 0x3a, 0x5, 0x28, 0xe, 0xc0,
0x5a, 0x3, 0xff, 0xb0, 0xa2, 0x88, 0x43, 0x4a,
0x0,
/* U+00FB "û" */
0x1, 0xa8, 0x15, 0xf9, 0x80, 0xa5, 0xb0, 0xec,
0x5, 0xa0, 0x3f, 0xfb, 0xa, 0x28, 0x84, 0x34,
0xa0,
/* U+00FC "ü" */
0x78, 0x1e, 0x8a, 0x5, 0x35, 0x0, 0x53, 0xd8,
0xb, 0x40, 0x7f, 0xf6, 0x14, 0x51, 0x8, 0x69,
0x40,
/* U+00FD "ý" */
0x2, 0x3d, 0x81, 0xbd, 0x60, 0x6c, 0x80, 0x4e,
0x0, 0xf3, 0x81, 0x8, 0x14, 0x10, 0xc8, 0x2,
0xc1, 0x70, 0x19, 0x10, 0x80, 0x31, 0x8, 0x18,
0xa4, 0x3, 0x21, 0x40, 0xd8, 0x10, 0x36, 0x40,
0x66, 0xdc, 0x9, 0x46, 0x80, 0x80,
/* U+00FE "þ" */
0xf0, 0xf, 0xfe, 0x41, 0xde, 0x81, 0x2b, 0x14,
0x0, 0xdf, 0x1, 0xd4, 0x10, 0x3f, 0xe6, 0x8,
0x1b, 0x1, 0x34, 0xdc, 0x1, 0x48, 0x50, 0x1,
0xde, 0x81, 0xff, 0xc4,
/* U+00FF "ÿ" */
0x19, 0x87, 0x80, 0x22, 0xa, 0x1, 0x10, 0x50,
0x4e, 0x0, 0xf3, 0x81, 0x8, 0x14, 0x10, 0xc8,
0x2, 0xc1, 0x70, 0x19, 0x10, 0x80, 0x31, 0x8,
0x18, 0xa4, 0x3, 0x21, 0x40, 0xd8, 0x10, 0x36,
0x40, 0x66, 0xdc, 0x9, 0x46, 0x80, 0x80,
/* U+011E "Ğ" */
0x1, 0x60, 0x94, 0xd, 0x17, 0x50, 0xc, 0x77,
0xc4, 0xc, 0xb7, 0xe8, 0x4, 0x6b, 0xb1, 0xd0,
0x10, 0xd4, 0xea, 0x21, 0x20, 0x12, 0x60, 0x5c,
0xd, 0x8, 0x1f, 0xfc, 0x13, 0xfc, 0x80, 0xc7,
0x50, 0x37, 0x0, 0x50, 0x12, 0x60, 0x7d, 0x6,
0x6a, 0x86, 0xe, 0x72, 0xbc, 0x40,
/* U+011F "ğ" */
0x7, 0x7e, 0xa0, 0xe, 0xfd, 0x40, 0xff, 0x5f,
0xa6, 0x19, 0x4a, 0xc0, 0x18, 0xdc, 0x8, 0x40,
0x7f, 0xf1, 0x88, 0x60, 0x72, 0xad, 0xc0, 0x2a,
0x95, 0x1, 0x5f, 0x8b, 0xe, 0x26, 0xd8, 0x23,
0x63, 0x60,
/* U+0130 "İ" */
0x6d, 0xb2, 0xdc, 0x7, 0xff, 0x28,
/* U+0131 "ı" */
0xd0, 0xf, 0xfe, 0x20,
/* U+0152 "Œ" */
0x0, 0xb7, 0xff, 0x81, 0xa2, 0x40, 0x52, 0x61,
0xce, 0x68, 0x76, 0xf0, 0x34, 0xf, 0xe2, 0x8,
0x1f, 0xf3, 0x3, 0x5f, 0xe4, 0x7, 0xd3, 0x69,
0x1, 0xf1, 0x38, 0x10, 0xc0, 0xff, 0x1e, 0x7,
0xfb, 0xaa, 0x98, 0x29, 0x60, 0x6b, 0xb4, 0x25,
0xb8,
/* U+0153 "œ" */
0x1, 0x3f, 0x30, 0xff, 0x30, 0xd, 0xa4, 0xac,
0x99, 0x8, 0xde, 0x48, 0xd9, 0x70, 0x18, 0x6,
0x18, 0x1, 0x64, 0x30, 0xc, 0x4f, 0xcc, 0x10,
0xc0, 0x31, 0x36, 0xb8, 0xc, 0x3, 0xe, 0x4e,
0x11, 0xbc, 0x5b, 0x28, 0xc3, 0x69, 0xf, 0x48,
0xa5, 0x0,
/* U+015E "Ş" */
0x1, 0x37, 0xc4, 0x4, 0x76, 0x9e, 0x0, 0xdc,
0xa8, 0x60, 0x38, 0x14, 0x21, 0x42, 0x1, 0xa1,
0x4e, 0xa8, 0xd, 0xab, 0xb4, 0x6, 0x5a, 0x24,
0x30, 0x9, 0x9c, 0x1a, 0x2, 0x20, 0xaa, 0xd5,
0x14, 0x57, 0x2b, 0xa4, 0x4, 0xc2, 0x20, 0x31,
0x9c, 0xe, 0x56, 0x0,
/* U+015F "ş" */
0x1, 0x7e, 0x40, 0x2b, 0xaa, 0x90, 0xaa, 0x88,
0x2, 0x88, 0x52, 0x2b, 0xb9, 0x1, 0x4e, 0xa9,
0x18, 0x88, 0x10, 0xe, 0x98, 0x23, 0xbb, 0x21,
0x3, 0x5a, 0x60, 0x68, 0xd0, 0x1a, 0xb4, 0x0,
/* U+0160 "Š" */
0x0, 0x88, 0x60, 0x67, 0xe6, 0x3, 0x14, 0xe8,
0x1d, 0x38, 0x1d, 0x37, 0xc4, 0x4, 0x76, 0x9e,
0x0, 0xdc, 0xa8, 0x60, 0x38, 0x14, 0x21, 0x42,
0x1, 0xa1, 0x4e, 0xa8, 0xd, 0xab, 0xb4, 0x6,
0x5a, 0x24, 0x30, 0x9, 0x9c, 0x1a, 0x2, 0x20,
0xaa, 0xd5, 0x14, 0x57, 0x2b, 0xa4,
/* U+0161 "š" */
0x1, 0x54, 0x80, 0x2b, 0xc, 0x3, 0x6a, 0x6,
0xbf, 0x20, 0x15, 0xd7, 0x40, 0x2a, 0xa8, 0x41,
0x44, 0x32, 0x15, 0xdc, 0xc0, 0xa7, 0x54, 0x88,
0x44, 0x8, 0x38, 0x98, 0x23, 0x3b, 0x21, 0x0,
/* U+017D "Ž" */
0x0, 0xea, 0xc0, 0x66, 0x6f, 0x3, 0xa7, 0x20,
0xf, 0xfe, 0x86, 0xdc, 0xc6, 0x9, 0x71, 0x40,
0x64, 0x78, 0x1d, 0x11, 0x3, 0x33, 0x0, 0xe8,
0xc8, 0x19, 0x88, 0x7, 0x46, 0x7, 0x41, 0x0,
0xe6, 0x97, 0x14, 0x15, 0xba, 0x0,
/* U+017E "ž" */
0x7, 0x1c, 0x80, 0x1f, 0xd1, 0x1, 0x1c, 0x80,
0x1f, 0xf8, 0x95, 0xb2, 0x4, 0x24, 0x6a, 0x1,
0xa1, 0x60, 0x49, 0x38, 0x1a, 0x22, 0x4, 0xcd,
0x3, 0x44, 0x4c, 0x10, 0x5b, 0x4c,
/* U+1E9E "ẞ" */
0x13, 0xf5, 0x2, 0x6d, 0x2b, 0xe4, 0x56, 0xc9,
0x9, 0x3, 0xc1, 0x70, 0xe, 0xed, 0x1, 0x89,
0x3a, 0x6, 0x3a, 0xbc, 0x6, 0x2a, 0x12, 0x3,
0x98, 0x1f, 0x30, 0x40, 0x13, 0x44, 0x5, 0x76,
0x2a, 0x0,
/* U+2022 "•" */
0x31, 0xe, 0xe9, 0x20, 0x28, 0x11,
/* U+20AC "€" */
0x2, 0x5b, 0xe0, 0x25, 0x55, 0xa0, 0x28, 0xa2,
0x60, 0x47, 0x1, 0x8f, 0x13, 0xd0, 0x7, 0x9,
0xe8, 0x3, 0x84, 0xf4, 0x1, 0xe2, 0x7a, 0x7,
0x70, 0x3c, 0x90, 0xf, 0x43, 0x53, 0x2, 0x35,
0xda, 0x0,
/* U+F0004 "" */
0x3, 0x8a, 0x3, 0xfa, 0x6b, 0xc8, 0x1e, 0x4c,
0xa, 0x1, 0xe2, 0x6, 0x60, 0x79, 0x1, 0x90,
0x1e, 0x34, 0x87, 0x0, 0xf9, 0x6f, 0x0, 0xf9,
0xdd, 0xa8, 0x80, 0x9f, 0x88, 0x99, 0xdc, 0x2,
0x1, 0xf8, 0xb2, 0x7, 0xfb, 0x9d, 0xbf, 0xd0,
/* U+F001B "" */
0x3, 0xff, 0x85, 0x3d, 0x0, 0xbc, 0x2, 0x6c,
0x14, 0x18, 0x36, 0x1, 0xc0, 0x98, 0x40, 0x38,
0x9, 0x68, 0x8e, 0x40, 0x50, 0x24, 0x8c, 0x1,
0x9c, 0x81, 0x5e, 0x80, 0x36, 0x3, 0x34, 0x3,
0x5, 0xf9, 0x0, 0xe0, 0x11, 0x40, 0x58, 0x4,
0x1, 0x84, 0x0, 0x60, 0x17, 0xac, 0x1f, 0x70,
0x12, 0x50, 0x2, 0x90, 0xa4, 0xd6, 0xb0, 0x9,
0xce, 0xb4, 0x6d, 0x10, 0xb, 0xb1, 0xf8, 0x48,
0x0, 0xc2, 0x3, 0xfa, 0xb0, 0x24, 0x82, 0x40,
0x25, 0x42, 0x36, 0x80,
/* U+F0026 "" */
0x3, 0xff, 0x97, 0x20, 0xf, 0xfe, 0x9, 0x6c,
0x40, 0xff, 0xe0, 0x40, 0x10, 0xf, 0xf9, 0x20,
0x4, 0x80, 0x7f, 0xa8, 0x90, 0x28, 0x1f, 0xd0,
0x1, 0x20, 0x10, 0xf, 0x8b, 0x3, 0xcc, 0x81,
0xe8, 0x5, 0xf8, 0xa, 0x1, 0xc9, 0x0, 0x92,
0x1, 0x24, 0x3, 0x40, 0x35, 0xa0, 0x34, 0x2,
0x64, 0xd, 0x68, 0xc, 0x58, 0x8, 0x7, 0xff,
0x2, 0x0,
/* U+F0045 "" */
0x3, 0x91, 0x3, 0xfd, 0x50, 0x1f, 0xfd, 0xd3,
0x40, 0xf9, 0xc0, 0x5e, 0x3, 0x9c, 0x2, 0xc3,
0x1, 0x38, 0xe0, 0x16, 0x18, 0x58, 0xe0, 0x1d,
0x80, 0x17, 0x0, 0xfb, 0x17, 0x0, 0xfe, 0xd0,
0xe,
/* U+F004D "" */
0x3, 0xff, 0x8b, 0x20, 0xf, 0xe8, 0xf8, 0x1f,
0xa3, 0x8c, 0xf, 0xa3, 0x8c, 0xf, 0xa3, 0x21,
0xbf, 0x10, 0x81, 0x93, 0xe6, 0x31, 0x2f, 0xfe,
0x40, 0x30, 0xc0, 0x7f, 0xb0, 0xc0, 0x7f, 0xb0,
0xa0, 0x7f, 0xb4, 0x3, 0x80,
/* U+F0054 "" */
0x3, 0xff, 0x8b, 0x18, 0x1f, 0xef, 0x18, 0x1f,
0xce, 0x43, 0x3, 0xf9, 0xc8, 0x60, 0xb, 0x7e,
0x6, 0x30, 0xed, 0xf8, 0x8a, 0x16, 0xdf, 0x12,
0xc0, 0x7e, 0xc3, 0x1, 0xfb, 0xc, 0x7, 0xea,
0x30, 0x1f, 0xd3, 0x1, 0xc0,
/* U+F005D "" */
0x3, 0xff, 0x8b, 0xa0, 0x1f, 0xd8, 0xb8, 0x7,
0xd8, 0x1, 0x70, 0xe, 0xc3, 0xb, 0x1c, 0x2,
0xc3, 0x1, 0x38, 0xe0, 0x2f, 0x1, 0xce, 0x0,
0x34, 0xf, 0x9c, 0x3, 0xff, 0xbd, 0x50, 0x1c,
/* U+F008E "" */
0x1, 0x6e, 0x0, 0x52, 0xf1, 0xd4, 0xd, 0x70,
0xbf, 0xea, 0x7, 0xff, 0xdb, 0xb7, 0xb8, 0x4e,
0xdc, 0xd0,
/* U+F009A "" */
0x3, 0xa4, 0x1, 0xfc, 0x9b, 0x20, 0x3e, 0x94,
0x5, 0x80, 0x75, 0x60, 0x67, 0x40, 0x8a, 0x3,
0xc8, 0x80, 0xa0, 0x7e, 0xa0, 0x8, 0x1f, 0x88,
0x1f, 0xfd, 0xa6, 0x7, 0xe6, 0x31, 0x3, 0xf1,
0xd2, 0xdf, 0xf4, 0x4b, 0x3b, 0x4d, 0x2c, 0x6,
0x3b, 0x8, 0x18,
/* U+F00AC "" */
0x76, 0xff, 0xf0, 0xc, 0x4b, 0xff, 0x82, 0x40,
0xff, 0xe0, 0x1c, 0xc0, 0xff, 0x64, 0x7, 0xff,
0xa8, 0x80, 0x96, 0xe0, 0xad, 0xc0, 0x64, 0xb0,
0xc9, 0x60, 0x3e, 0xa2, 0x20, 0x3f, 0x8a, 0xab,
0x81, 0xfc, 0x47, 0x44, 0xf, 0xf5, 0x6a, 0x1,
0xc0,
/* U+F00AF "" */
0x3, 0x20, 0x3f, 0x4a, 0x7, 0xe5, 0x40, 0x4e,
0x40, 0x24, 0xa2, 0x1c, 0x46, 0x69, 0x6, 0x38,
0xd7, 0x10, 0xc, 0x41, 0x8c, 0xd, 0x40, 0x30,
0x33, 0x80, 0x30, 0x13, 0x90, 0x58, 0xc1, 0xc8,
0x63, 0xb2, 0x68, 0xc0, 0x45, 0x8a, 0x60, 0x6c,
0x40, 0xe7, 0x88, 0x0,
/* U+F00ED "" */
0x0, 0x80, 0xf2, 0x3, 0x54, 0x6, 0x54, 0x4,
0xe2, 0xff, 0xa8, 0xf1, 0x81, 0xfe, 0x60, 0x7f,
0xf0, 0x5d, 0xbf, 0x98, 0xc, 0x97, 0xec, 0x7,
0xff, 0x1f, 0xf9, 0x1, 0xff, 0xd4, 0xb6, 0x40,
0x59, 0x2c, 0x4, 0xb0, 0x6d, 0x6f, 0xe6, 0xc0,
/* U+F010B "" */
0xb, 0x6f, 0xc8, 0x4, 0x8d, 0xbd, 0x20, 0x12,
0x40, 0x79, 0x12, 0x48, 0x7, 0xe4, 0x94, 0x37,
0xf8, 0x52, 0xa4, 0xfc, 0x88, 0x9c, 0xe, 0x5e,
0x0, 0xe4, 0xe, 0x67, 0x0, 0x78, 0xe, 0x39,
0x1, 0x13, 0xf8, 0xd, 0xb7, 0xe0, 0x1b, 0x0,
0xfd, 0xb0,
/* U+F011C "" */
0x32, 0x7c, 0xc7, 0x6f, 0xe8, 0x80, 0xfe, 0x21,
0xff, 0xe0, 0x2e, 0x7, 0xff, 0xfc, 0xd, 0x64,
0xf0, 0x11, 0x6f, 0xc0, 0x10, 0x1f, 0x94, 0xff,
0xf1,
/* U+F012C "" */
0x3, 0xff, 0x95, 0x68, 0xf, 0xea, 0xa0, 0x1f,
0xaa, 0xc4, 0xf, 0xaa, 0xc4, 0x1a, 0x6, 0xab,
0x10, 0x25, 0x40, 0x55, 0x88, 0x11, 0xca, 0xd2,
0xc4, 0xe, 0x39, 0x26, 0x20, 0x7c, 0x76, 0x10,
0x3c,
/* U+F0140 "" */
0x3, 0xf5, 0xa0, 0x35, 0xa8, 0xa8, 0xa, 0xa1,
0xca, 0xd2, 0xc4, 0x1c, 0x93, 0x10, 0x23, 0xb0,
0x80,
/* U+F0141 "" */
0x2, 0x34, 0x8, 0xe0, 0x23, 0x95, 0x7, 0x2a,
0x7, 0xe3, 0x95, 0x2, 0x39, 0x50, 0x23, 0x80,
0x0,
/* U+F0142 "" */
0x14, 0x81, 0xd8, 0x81, 0x55, 0x88, 0x15, 0x58,
0x81, 0xfa, 0xac, 0x45, 0x58, 0x81, 0x62, 0x0,
/* U+F0143 "" */
0x2, 0x24, 0x7, 0x1d, 0x84, 0x8, 0xe4, 0x98,
0x83, 0x95, 0xa5, 0x8c, 0x54, 0x5, 0x52, 0xd0,
0x1a, 0xd0,
/* U+F0150 "" */
0x3, 0x93, 0x62, 0x7, 0xe9, 0xec, 0x8d, 0x84,
0xe, 0xce, 0x7f, 0x67, 0x90, 0x15, 0x39, 0x82,
0xd, 0x74, 0x82, 0xa9, 0x1, 0x80, 0xa1, 0x82,
0x94, 0x7, 0xea, 0x81, 0x60, 0x7f, 0x20, 0x41,
0x3, 0x98, 0x11, 0x0, 0x48, 0xd, 0xb4, 0x42,
0x7, 0x20, 0x31, 0xb2, 0x7, 0x21, 0x1a, 0x7,
0x2a, 0x92, 0x0, 0xea, 0x81, 0xca, 0xa4, 0x0,
0x72, 0xf5, 0xcd, 0x5d, 0x3, 0x1f, 0x5, 0x49,
0xa0, 0x10,
/* U+F0156 "" */
0x8, 0xf, 0x20, 0xab, 0x3, 0x3a, 0x92, 0x43,
0x0, 0xe4, 0x20, 0xe4, 0x36, 0x90, 0xc0, 0x9c,
0x99, 0x81, 0xff, 0xc2, 0x72, 0x66, 0x4, 0xe4,
0x36, 0x90, 0xc2, 0x90, 0xc0, 0x39, 0x9, 0x2b,
0x3, 0x3a, 0x80,
/* U+F0176 "" */
0x13, 0xff, 0xf8, 0x81, 0xfe, 0x34, 0x20, 0x3f,
0xe4, 0x40, 0xff, 0x8b, 0x20, 0x7f, 0xf0, 0x29,
0x60, 0x7f, 0x8e, 0xc0, 0x3f, 0xf8, 0x9c, 0xf,
0xcc, 0xc, 0xd0, 0x1f, 0x40, 0x3a, 0xeb, 0x7b,
0x90, 0x24, 0xa6, 0x7, 0x25, 0x0, 0x96, 0xff,
0xc0, 0x0,
/* U+F01D9 "" */
0x9, 0x83, 0x62, 0x20, 0x18, 0xfc, 0x42, 0x60,
0xd8, 0x88, 0x6, 0x3f, 0x10, 0x98, 0x36, 0x22,
0x1, 0x8f, 0xc4,
/* U+F01FA "" */
0x3, 0x92, 0xe0, 0x3f, 0xca, 0xde, 0x3, 0xfc,
0xbd, 0x1f, 0x80, 0xff, 0x5d, 0x46, 0xd8, 0x12,
0x6, 0x8, 0x88, 0x2, 0x70, 0xf8, 0x36, 0x4,
0xf, 0xc4, 0x80, 0xd1, 0x81, 0xfb, 0x1, 0xc8,
0x81, 0xff, 0xc2, 0xc8, 0xf, 0xd0, 0xc, 0x41,
0x20, 0x3e, 0x64, 0x2, 0xc2, 0x6e, 0x40, 0xf5,
0x80, 0x7d, 0xbf, 0xe0, 0xd8, 0x0,
/* U+F0210 "" */
0x3, 0x8d, 0xd4, 0x81, 0xfd, 0xd1, 0x5c, 0xf,
0xe2, 0x4, 0xc0, 0xff, 0xe0, 0x2a, 0x6, 0x3f,
0x0, 0x40, 0x28, 0x1d, 0x1, 0xc4, 0x80, 0x5d,
0xfb, 0x1, 0x8e, 0x6e, 0x44, 0x1, 0x84, 0xf,
0xfe, 0x1, 0x84, 0x1, 0x4d, 0xd8, 0x80, 0x23,
0x7e, 0xd4, 0x1, 0x2c, 0x45, 0x3, 0xa8, 0x4,
0x3, 0x72, 0x6, 0xa8, 0xf, 0xfe, 0x3, 0x2,
0x20, 0x7f, 0x74, 0x56, 0x3, 0x80,
/* U+F0238 "" */
0x3, 0xa8, 0x1f, 0xb2, 0x3, 0xea, 0x40, 0xfc,
0x80, 0x50, 0x33, 0x40, 0x4a, 0x80, 0x38, 0x8,
0x85, 0x85, 0x48, 0x2, 0x20, 0x51, 0x18, 0x1,
0xa0, 0x36, 0x2, 0x1, 0x2, 0x1, 0x1, 0x42,
0x88, 0xc6, 0x0, 0x9e, 0x84, 0x81, 0xd4, 0x0,
0xca, 0x4, 0xaf, 0xec, 0xc0, 0x0,
/* U+F028F "" */
0xd, 0xfc, 0x86, 0x93, 0xea, 0x8c, 0xff, 0xc0,
0x80, 0xec, 0xf, 0xd5, 0x1, 0xf4, 0xbb, 0xfc,
0x4, 0xad, 0xf0, 0x16, 0xa5, 0x2c, 0x7, 0xff,
0xb, 0xb0, 0x3f, 0xf8, 0x87, 0x25, 0xe0, 0x9,
0x2d, 0xf0, 0x52, 0xbf, 0xec, 0xb9,
/* U+F02DA "" */
0x3, 0xd3, 0x7e, 0xa4, 0xf, 0x97, 0x6a, 0x40,
0xd0, 0xe, 0x35, 0xf8, 0xda, 0xd3, 0x60, 0x34,
0x30, 0x5, 0x0, 0xa4, 0x1, 0x94, 0x2, 0x40,
0x4c, 0x30, 0x8, 0x20, 0x3f, 0x2e, 0x35, 0x1d,
0x81, 0x40, 0x3d, 0x88, 0x8c, 0x7, 0x1c, 0x85,
0xc0, 0x68, 0xc0, 0xd3, 0x16, 0x18, 0x13, 0xc,
0xc, 0x54, 0x80, 0x38, 0xcf, 0x13, 0xd5, 0xb0,
0x1c, 0x7b, 0x56, 0x3d, 0x0, 0x0,
/* U+F02DC "" */
0x3, 0xd5, 0x1, 0xff, 0x65, 0x58, 0x1f, 0x8e,
0x20, 0x24, 0x1, 0xe3, 0x88, 0x19, 0xc0, 0x32,
0xc0, 0x7c, 0xe8, 0x5, 0x40, 0xfe, 0x58, 0x2e,
0x40, 0xfd, 0x30, 0x1e, 0x56, 0x80, 0xff, 0xb2,
0x40, 0x3f, 0xfb, 0x12, 0xd2, 0x1, 0x6c, 0x80,
0x0,
/* U+F02E3 "" */
0x58, 0xf, 0xfe, 0x19, 0x6, 0x20, 0xa4, 0xe6,
0x7, 0x67, 0x57, 0x6f, 0xa5, 0x2, 0x40, 0x58,
0xf, 0x91, 0x0, 0x80, 0xb0, 0x1f, 0x98, 0x17,
0x99, 0x1, 0xff, 0x6c, 0xbf, 0x20, 0x3f, 0xc4,
0xf0, 0x1f, 0xf7, 0xff, 0xfc, 0x0, 0x3f, 0xf8,
0xcb, 0x81, 0xff, 0xc0, 0xe8,
/* U+F030B "" */
0x0, 0xf6, 0x42, 0x7, 0xeb, 0x9, 0x3c, 0x40,
0xf2, 0x56, 0x40, 0x38, 0x1e, 0xe3, 0x98, 0x0,
0x90, 0x1f, 0x71, 0x40, 0xfe, 0x21, 0x76, 0x7,
0xf5, 0x3, 0xec, 0x40, 0xc7, 0x10, 0x3d, 0x88,
0x18, 0xeb, 0x60, 0x36, 0x20, 0x72, 0x55, 0x48,
0x3, 0x10, 0x3e, 0x56, 0x80, 0xb1, 0x3, 0xf9,
0x20, 0xa, 0x7, 0xf5, 0xa0, 0x3f, 0xf8, 0x49,
0x38,
/* U+F0322 "" */
0x0, 0x97, 0xff, 0x0, 0xa, 0x5b, 0xff, 0xc0,
0x80, 0xa, 0xff, 0xfc, 0x88, 0x1f, 0xff, 0xf0,
0x3f, 0x34, 0xbf, 0xcc, 0xb, 0x9b, 0x7f, 0xc7,
0x8f, 0x40, 0xff, 0xe0, 0x5f, 0x6f, 0xff, 0x10,
/* U+F032A "" */
0x3, 0xff, 0x80, 0x50, 0x1f, 0x17, 0x2f, 0xc0,
0x65, 0x7f, 0x68, 0xd0, 0x4, 0x2, 0xd2, 0x0,
0x51, 0x0, 0x80, 0x54, 0x1, 0x56, 0x88, 0xe,
0x12, 0x0, 0xbe, 0xa0, 0x22, 0x86, 0x1, 0x45,
0x3, 0xa0, 0x19, 0xb5, 0x3, 0x92, 0x0, 0xa2,
0x70, 0x38, 0xd0, 0x23, 0x91, 0x3, 0x1c, 0x7,
0x1e, 0x6, 0x78, 0xf, 0x15, 0x2e, 0xf0, 0xf,
0xcd, 0x91, 0x3, 0xf0,
/* U+F0335 "" */
0x2, 0x72, 0x10, 0x18, 0xf8, 0xda, 0xe0, 0x2c,
0x7, 0x1c, 0x18, 0x1f, 0x15, 0x80, 0xfc, 0x40,
0xff, 0x60, 0x3f, 0x16, 0x7, 0xc5, 0xc, 0x7,
0x1c, 0x0, 0x90, 0x19, 0x1, 0x98, 0x1b, 0x81,
0xaf, 0xf9, 0x81, 0xcd, 0xe0, 0x3d, 0x6d, 0x80,
0x80,
/* U+F033E "" */
0x3, 0x8a, 0x3, 0xfb, 0x65, 0xec, 0xf, 0x51,
0xbc, 0x84, 0x7, 0x28, 0x43, 0x5c, 0xf, 0x30,
0x22, 0xc0, 0x8c, 0x15, 0xb9, 0x16, 0x3, 0x30,
0xe4, 0x88, 0x94, 0x81, 0xfe, 0x60, 0x7f, 0xf1,
0x77, 0x60, 0x7f, 0x11, 0x80, 0xfe, 0xae, 0x81,
0xfc, 0xa0, 0x1c, 0x40, 0xff, 0xe0, 0x32, 0x7,
0xc6, 0x0,
/* U+F0374 "" */
0x6f, 0xf8, 0xd9, 0x3f, 0x20,
/* U+F03E4 "" */
0x6c, 0x80, 0x26, 0xd2, 0x38, 0xf, 0x20, 0xf,
0xff, 0x61, 0x30, 0x2, 0x60,
/* U+F040A "" */
0x20, 0x7d, 0x31, 0x3, 0xc7, 0x40, 0x3e, 0x79,
0x1, 0xe3, 0x68, 0xf, 0x99, 0x3, 0xa6, 0x20,
0x4b, 0x30, 0x34, 0xa4, 0xb, 0xf3, 0x3, 0x80,
/* U+F0415 "" */
0x3, 0x32, 0x7, 0xe8, 0x80, 0xff, 0xe6, 0x37,
0x86, 0x6e, 0x36, 0x48, 0x29, 0x25, 0xbf, 0x84,
0xfe, 0x60, 0x7f, 0xf3, 0x8, 0x1c,
/* U+F0425 "" */
0x3, 0xb3, 0x3, 0xff, 0x80, 0x40, 0xde, 0x1,
0xb4, 0x1, 0x4c, 0x3, 0x56, 0x82, 0x80, 0x72,
0x4e, 0x82, 0x3, 0xd9, 0x1, 0xc8, 0x81, 0x14,
0x10, 0x8, 0x80, 0x66, 0x14, 0x3, 0x92, 0x71,
0x4e, 0x40, 0x1d, 0x68, 0x6, 0x77, 0xf4, 0x90,
0x11, 0xba, 0xd7, 0x60, 0x0,
/* U+F0438 "" */
0x2, 0x40, 0xa, 0x0, 0x50, 0x1a, 0xc0, 0x1f,
0x80, 0x7e, 0x2, 0x2a, 0x82, 0x50, 0x12, 0xe0,
0x45, 0x40, 0x57, 0x5, 0x40, 0x33, 0x20, 0x1b,
0x0, 0x6c, 0x4, 0x47, 0x5, 0xd0, 0x5d, 0x2,
0x38, 0x83, 0x40, 0x1a, 0x4, 0xff, 0xff, 0xb0,
0xa1, 0x91, 0x2, 0x61, 0x92, 0x64, 0x5a, 0xc,
0x6a, 0x2a, 0x3, 0x3e, 0x8, 0xec, 0x32, 0x6,
0xac, 0x60, 0xe8, 0xa8, 0x9, 0x5b, 0xfe, 0x0,
0xfa, 0x5f, 0xe6, 0x40,
/* U+F0456 "" */
0x3, 0xff, 0x97, 0x88, 0x13, 0x7f, 0x8e, 0x20,
0x2c, 0xb7, 0xc0, 0x10, 0x14, 0xdb, 0xc2, 0x30,
0x3f, 0xd1, 0x81, 0x54, 0x7, 0x98, 0x19, 0x90,
0x3f, 0xf8, 0xfd, 0x81, 0x36, 0x3, 0xfc, 0xe6,
0x6f, 0xc0, 0x6a, 0x15, 0xbe, 0x24, 0x3, 0x19,
0xb7, 0xc8, 0xb, 0x10, 0x3f, 0x80,
/* U+F0457 "" */
0x3, 0xff, 0x97, 0x88, 0x90, 0xb, 0x7e, 0x38,
0xd7, 0xe, 0x93, 0x80, 0x23, 0x9c, 0xbf, 0xf0,
0x8c, 0x10, 0xe0, 0x1d, 0x18, 0x14, 0x87, 0x0,
0xcc, 0xc, 0xdb, 0x38, 0x7, 0xf8, 0xe7, 0x0,
0x76, 0x5, 0x18, 0x39, 0xc0, 0x80, 0xa3, 0xcd,
0x92, 0x39, 0x50, 0x4, 0x14, 0x92, 0xe, 0x10,
0x18, 0xcf, 0xfb, 0x38, 0x5, 0x88, 0x1c, 0x70,
0x0,
/* U+F0458 "" */
0x3, 0xff, 0x97, 0x88, 0x13, 0x7f, 0x8e, 0x20,
0x2c, 0xb7, 0xc0, 0x10, 0x14, 0xdb, 0xc2, 0x30,
0x39, 0x72, 0x2, 0xb0, 0x2a, 0x81, 0x3, 0x20,
0x33, 0x21, 0x90, 0x3f, 0x88, 0x1e, 0xec, 0xa,
0x20, 0x18, 0x81, 0xe8, 0xf3, 0x7e, 0x3, 0x20,
0xad, 0xf1, 0x20, 0x18, 0xcd, 0xbe, 0x40, 0x58,
0x81, 0xfc,
/* U+F0493 "" */
0x3, 0x93, 0x64, 0x7, 0xfa, 0x4b, 0x81, 0xf2,
0x0, 0x40, 0x20, 0x8, 0xa, 0x5f, 0xc0, 0x6f,
0xd6, 0x2, 0xc0, 0xff, 0x32, 0xc0, 0xcf, 0xf3,
0x3, 0x35, 0x80, 0x18, 0x2, 0x10, 0x19, 0x2,
0x1, 0x81, 0x98, 0x2, 0x2, 0x80, 0x44, 0x1,
0x40, 0x28, 0x48, 0x5, 0xa4, 0x60, 0x24, 0xa2,
0x6, 0x6c, 0x6, 0x28, 0x73, 0x20, 0xd, 0x20,
0xf0, 0x7, 0x36, 0x20, 0xb, 0x6c, 0x40, 0xf2,
0x24, 0x80, 0xe0,
/* U+F049D "" */
0x8, 0xf, 0x49, 0x11, 0x68, 0xe, 0xcd, 0xc2,
0xaa, 0x6, 0xe0, 0x65, 0x55, 0x1, 0x55, 0xa0,
0x25, 0x70, 0xaa, 0xa5, 0x1, 0x27, 0x55, 0x40,
0x7d, 0x55, 0x40, 0x7d, 0x55, 0x5a, 0x80, 0x20,
0x2a, 0xa8, 0x45, 0x69, 0x8a, 0xaa, 0x0, 0xaa,
0x40, 0xe, 0xa0, 0x37, 0x3, 0x64, 0x7, 0x5f,
0xc8,
/* U+F049E "" */
0x3, 0xe4, 0x41, 0x4b, 0xdb, 0xc, 0xb7, 0xcc,
0x4b, 0xff, 0xa9, 0xa0, 0x7c, 0xf0, 0x1f, 0xfc,
0x67, 0x85, 0xff, 0xd4, 0xd9, 0x6f, 0x98, 0x85,
0x2f, 0x6c, 0x20,
/* U+F04AD "" */
0xa0, 0x72, 0xeb, 0x90, 0x3e, 0xd0, 0xf, 0x9e,
0x20, 0x7f, 0xf0, 0x5e, 0x20, 0x6d, 0x0, 0xcb,
0x90, 0x38,
/* U+F04AE "" */
0xe8, 0xe, 0xa0, 0x71, 0xe8, 0xd, 0x30, 0x18,
0xe6, 0x7, 0xff, 0x4, 0xe6, 0x7, 0xd3, 0x1,
0xf1, 0xe8,
/* U+F04B9 "" */
0x2, 0x76, 0xa1, 0x12, 0xd4, 0x3, 0xd1, 0x23,
0x90, 0xd2, 0x38, 0x7, 0xf8, 0x81, 0xf8, 0xa6,
0x7, 0xe3, 0x10, 0xd, 0x78, 0x1f, 0xa7, 0xac,
0xb, 0x90, 0x3e, 0x60, 0x38, 0x1a, 0x5a, 0x91,
0x6c, 0x40, 0xf3, 0xb6, 0xd9, 0x6d, 0xc0, 0xff,
0xe4, 0x40, 0x52, 0xfe, 0xa, 0x6, 0x55, 0xbf,
0xc3, 0x80,
/* U+F04C3 "" */
0xd, 0xfc, 0x86, 0x93, 0xea, 0x80, 0x97, 0xc0,
0x44, 0x8, 0x82, 0x7, 0xce, 0x50, 0x3f, 0x34,
0x7, 0x8e, 0xfd, 0x0, 0xec, 0xbe, 0x50, 0x9,
0x88, 0xc, 0x60, 0x5c, 0xf, 0xec, 0x20, 0x30,
0x81, 0x26, 0xdf, 0x1e, 0x6, 0x95, 0xce, 0x41,
0xa4, 0x9d, 0x44, 0x92, 0x0,
/* U+F04DB "" */
0xff, 0xf0, 0x1f, 0xfe, 0xc0,
/* U+F04DE "" */
0x0, 0xed, 0x40, 0xad, 0x40, 0x32, 0x89, 0x1a,
0x89, 0x1b, 0x11, 0x68, 0xd, 0x48, 0x14, 0xc5,
0x4d, 0xfe, 0xdf, 0xb7, 0x8, 0x4, 0x20, 0x55,
0x8c, 0x6, 0xdd, 0xa5, 0x62, 0xaa, 0x2, 0x56,
0xff, 0x80, 0xa7, 0xff, 0xe0, 0x3a, 0x10, 0xa,
0x1, 0xfa, 0xe2, 0x10, 0xa0, 0x7c, 0x73, 0x1,
0x39, 0x2, 0x39, 0x23, 0x9, 0x41, 0xa0, 0x15,
0x5b, 0xfe, 0x2d, 0xaa, 0xdf, 0xf9, 0x26, 0x0,
/* U+F0502 "" */
0x1b, 0xff, 0xfe, 0x6, 0x8, 0xdb, 0xff, 0xc0,
0x28, 0x2, 0x5f, 0xfc, 0x0, 0x3f, 0xff, 0xe0,
0x7f, 0xf3, 0x5b, 0xff, 0xe0, 0x0, 0x49, 0x6d,
0x27, 0xad, 0x92, 0xb, 0xb4, 0x40, 0xd3, 0x6a,
0x81, 0xef, 0xb6, 0x60, 0x70,
/* U+F050F "" */
0x2, 0x48, 0x7, 0x5b, 0x80, 0xca, 0x42, 0x3,
0x89, 0x1, 0xef, 0xc0, 0x79, 0x20, 0x1f, 0xfc,
0x88, 0x6, 0x80, 0xb0, 0x33, 0x2c, 0xf, 0x36,
0x3, 0xcc, 0xa0, 0x32, 0x22, 0xc2, 0x52, 0x80,
/* U+F051B "" */
0x3, 0x25, 0x80, 0xfd, 0x6e, 0x3, 0xf7, 0xb5,
0x80, 0xf1, 0xbe, 0xd6, 0xc3, 0x48, 0x59, 0xdf,
0xd4, 0x64, 0x2, 0xac, 0xa4, 0x2c, 0x81, 0x82,
0x80, 0x24, 0x2, 0x88, 0x98, 0x1f, 0x9a, 0x3c,
0xf, 0xdc, 0x81, 0xd6, 0x80, 0xe5, 0x80, 0xfd,
0x97, 0x44, 0xf, 0x15, 0xd2, 0x64, 0x6, 0x59,
0x20, 0xaa, 0xd4, 0x8b, 0x4a, 0x81, 0x5a, 0x9,
0x5, 0xa0, 0x0,
/* U+F0565 "" */
0x3, 0x89, 0x1, 0xf8, 0xdd, 0x94, 0x81, 0x96,
0xc4, 0x1, 0x6c, 0x43, 0x52, 0x7, 0x8d, 0xc4,
0xf, 0xf1, 0x3, 0xf3, 0x60, 0x3f, 0x9c, 0xe0,
0x7e, 0x71, 0xc0, 0x4, 0x5a, 0xe, 0x38, 0x0,
0xb1, 0x16, 0x8e, 0x1, 0x3e, 0xe, 0x2e, 0x1,
0xba, 0x20, 0xf8, 0x6, 0x28, 0x70, 0x3f, 0x70,
0x6, 0x81, 0xea, 0x40, 0x96, 0x40, 0x16, 0x40,
0x71, 0xbb, 0x29, 0x2,
/* U+F057E "" */
0x3, 0xe6, 0xc0, 0x7e, 0xc0, 0x26, 0x3, 0xd8,
0x87, 0x86, 0x3, 0x62, 0x1, 0x1e, 0x5f, 0xf1,
0x2, 0xf0, 0xaa, 0x7, 0xe6, 0x31, 0x3, 0xff,
0x90, 0xc6, 0x3f, 0xc4, 0xb, 0xc2, 0xa8, 0x16,
0x20, 0x11, 0xe5, 0x81, 0xb1, 0xf, 0xc, 0x7,
0xb0, 0x9, 0x80, 0x0,
/* U+F0580 "" */
0x3, 0xff, 0x87, 0x40, 0xfd, 0x50, 0x1f, 0x54,
0x1, 0x0, 0xdf, 0x90, 0x16, 0xa0, 0x7f, 0x20,
0x3f, 0xf8, 0xe8, 0x6f, 0xc8, 0xb, 0x50, 0x35,
0x40, 0x10, 0x1e, 0xa8, 0xf, 0xea, 0x6,
/* U+F058C "" */
0x2, 0x48, 0x7, 0x1b, 0x44, 0xd, 0xc0, 0x70,
0x26, 0x40, 0x16, 0x2, 0x1, 0xa0, 0x80, 0x7a,
0x20, 0x3c, 0x88, 0x1e, 0x24, 0x7, 0x8c, 0x3,
0xd1, 0x40, 0x34, 0x41, 0xfb, 0x5d, 0x80,
/* U+F058E "" */
0x2, 0x48, 0x7, 0x1b, 0x44, 0xd, 0xc0, 0x70,
0x26, 0x40, 0x16, 0x2, 0x10, 0x28, 0x21, 0xc4,
0xb8, 0x88, 0xe1, 0xb0, 0x22, 0x3, 0x60, 0x2,
0x43, 0x60, 0xc4, 0xa0, 0xe4, 0xb1, 0x8a, 0x1,
0x18, 0x83, 0xf6, 0xbb, 0x0,
/* U+F058F "" */
0x0, 0x6d, 0x30, 0x3f, 0xdd, 0x24, 0x3, 0xf9,
0x90, 0x2b, 0x7a, 0x0, 0x30, 0xc, 0x97, 0x38,
0x9, 0x1, 0xff, 0xc1, 0xc0, 0x6d, 0xfc, 0x7,
0xff, 0x5, 0x0, 0x20, 0x7f, 0xb0, 0x6, 0x7,
0xfa, 0x7e, 0xc0, 0x7f, 0xcb, 0x1, 0xff, 0xc0,
0xa5, 0x87, 0xc0, 0xda, 0x81, 0xea, 0x7, 0x90,
0xf, 0x58, 0x4b, 0xf0, 0x12, 0x0,
/* U+F0590 "" */
0x3, 0xc5, 0xb1, 0x3, 0xfe, 0x9a, 0x46, 0xa0,
0x7f, 0x47, 0x7f, 0x55, 0x0, 0xf3, 0xaf, 0x20,
0xb, 0x30, 0x3a, 0x40, 0x64, 0xc, 0x4a, 0x20,
0x5, 0xda, 0x80, 0x79, 0x3b, 0x3, 0x8, 0xf,
0xd3, 0xd6, 0x58, 0x40, 0x7f, 0x90, 0x65, 0x58,
0xdf, 0xf6, 0x8, 0x58, 0xa4, 0xfd, 0x5e, 0x0,
/* U+F0591 "" */
0x3, 0x8d, 0xfd, 0x48, 0x1f, 0xc7, 0x39, 0x3,
0x20, 0x3e, 0x5d, 0x66, 0xd6, 0x50, 0x38, 0xfa,
0x68, 0x19, 0x94, 0x6, 0xcb, 0xf0, 0x1e, 0x57,
0x20, 0x85, 0x3, 0xf5, 0xa7, 0x4b, 0x40, 0x7f,
0x15, 0x50, 0x34, 0xf, 0xfe, 0x5, 0x22, 0x7f,
0xf2, 0xbf, 0xd0, 0x4, 0xb7, 0xe5, 0x2d, 0xc0,
0x72, 0x3, 0x26, 0x7, 0xa5, 0xa3, 0x6f, 0xf8,
0x0,
/* U+F0592 "" */
0x3, 0xc5, 0xb1, 0x3, 0xfe, 0x9a, 0x46, 0xa0,
0x7f, 0x47, 0x7f, 0x55, 0x0, 0xf3, 0xaf, 0x20,
0xb, 0x30, 0x3a, 0x40, 0x64, 0xc, 0x4a, 0x20,
0x5, 0xda, 0x80, 0x79, 0x3b, 0x3, 0x8, 0xf,
0xd3, 0xd6, 0x58, 0x40, 0x52, 0x0, 0xe4, 0x19,
0x56, 0x10, 0xd8, 0x8, 0xbc, 0x10, 0xb1, 0x20,
0xfc, 0x4, 0xab, 0xc0, 0x4f, 0x30, 0x23, 0xe3,
0xd4, 0x81, 0xe5, 0xe1, 0x74, 0xf, 0xf6, 0xc,
0x42, 0x7, 0xfa, 0x3a, 0x7, 0xe0,
/* U+F0593 "" */
0x3, 0xc5, 0xb1, 0x3, 0xfe, 0x9a, 0x46, 0xa0,
0x7f, 0x47, 0x7f, 0x55, 0x0, 0xf3, 0xaf, 0x20,
0xb, 0x30, 0x3a, 0x40, 0x64, 0xc, 0x4a, 0x20,
0x5, 0xda, 0x80, 0x79, 0x3b, 0x3, 0x8, 0xe,
0x6c, 0x27, 0xac, 0xb0, 0x80, 0xce, 0x70, 0x24,
0x19, 0x56, 0x30, 0x14, 0x40, 0x5e, 0x8, 0x58,
0xa9, 0x30, 0xa1, 0x57, 0x80, 0x9e, 0xc2, 0xd8,
0x70, 0xf5, 0x20, 0x7c, 0xa9, 0x40, 0x7f, 0xf0,
0x5f, 0x3, 0xff, 0x84, 0xc8, 0x1f, 0x0,
/* U+F0594 "" */
0x3, 0xff, 0x92, 0x90, 0xf, 0xcc, 0x15, 0xf9,
0x10, 0x3b, 0x44, 0x62, 0x48, 0x40, 0xd4, 0x82,
0x20, 0x8, 0x6, 0x2a, 0x9e, 0xe, 0xc2, 0x6,
0x41, 0x28, 0x32, 0x4c, 0x20, 0x1d, 0xa, 0x58,
0x1a, 0xd3, 0x3, 0x17, 0x8, 0x11, 0x8, 0x74,
0x2, 0x1c, 0x80, 0x5e, 0x1, 0x4, 0x3, 0x3b,
0xa2, 0x42, 0xa, 0xa0, 0x53, 0x24, 0x95, 0x80,
0xa7, 0xa0, 0x6, 0x40, 0x2c, 0xb, 0x2b, 0xed,
0x7a, 0xb0, 0x1d, 0x74, 0x25, 0x35, 0x2,
/* U+F0595 "" */
0x3, 0xf2, 0x60, 0x7e, 0xcc, 0xd, 0x80, 0xfd,
0x1a, 0x90, 0x28, 0x1f, 0x95, 0xa2, 0xac, 0x3,
0xf3, 0x5a, 0xea, 0xc9, 0x80, 0x90, 0xc8, 0x84,
0xcd, 0x38, 0x1, 0xa0, 0x4f, 0xdc, 0x40, 0x60,
0x7, 0xc, 0xa4, 0x7e, 0x6c, 0x48, 0x8, 0x97,
0xd, 0x80, 0x45, 0x0, 0xc7, 0x24, 0xa0, 0x6c,
0x90, 0xa, 0x2d, 0x48, 0x1e, 0xbc, 0x81, 0xfe,
0x7f, 0x82, 0x1d, 0x46, 0xff, 0x80, 0x94, 0x52,
0x7e, 0xad, 0x80,
/* U+F0596 "" */
0x3, 0xc5, 0xb1, 0x3, 0xfe, 0x9a, 0x46, 0xa0,
0x7f, 0x47, 0x7f, 0x55, 0x0, 0xf3, 0xaf, 0x20,
0xb, 0x30, 0x3a, 0x40, 0x64, 0xc, 0x4a, 0x20,
0x5, 0xda, 0x80, 0x79, 0x3b, 0x3, 0x8, 0xf,
0xd3, 0xd6, 0x58, 0x40, 0x2a, 0x3c, 0x3a, 0x10,
0x65, 0x52, 0x10, 0x40, 0x29, 0x14, 0x21, 0x61,
0x41, 0x64, 0xe, 0x1b, 0x0, 0x98, 0xc8, 0x2c,
0x82, 0xc, 0x81, 0xd6, 0x10, 0x92, 0x81, 0xfc,
0x49, 0x12, 0x8, 0xf, 0xf9, 0x70, 0x3f, 0x0,
/* U+F0597 "" */
0x3, 0xc5, 0xb1, 0x3, 0xfe, 0x9a, 0x46, 0xa0,
0x7f, 0x47, 0x7f, 0x67, 0x0, 0xf2, 0xae, 0xa0,
0x7, 0xb0, 0x3a, 0x50, 0xd0, 0x18, 0xa8, 0x80,
0x17, 0x6a, 0x1, 0xe2, 0xec, 0xc, 0x20, 0x38,
0x80, 0x9e, 0xb2, 0xc2, 0x3, 0x5e, 0x6, 0x41,
0x95, 0x61, 0xd, 0x1a, 0xb, 0xc1, 0xb, 0x12,
0x8, 0xea, 0x2a, 0xbc, 0x4, 0xf3, 0x61, 0x11,
0xaf, 0x52, 0x7, 0xb9, 0x0, 0xc8, 0x1f, 0xea,
0x6c, 0x5c, 0xf, 0xf1, 0xa0, 0xd4, 0x7, 0x0,
/* U+F0598 "" */
0x3, 0xc5, 0xb1, 0x3, 0xfe, 0x9a, 0x46, 0xa0,
0x7f, 0x47, 0x7f, 0x55, 0x0, 0xf3, 0xaf, 0x20,
0xb, 0x30, 0x3a, 0x40, 0x64, 0xc, 0x4a, 0x20,
0x5, 0xda, 0x80, 0x79, 0x3b, 0x3, 0x8, 0xf,
0xd3, 0xd6, 0x58, 0x40, 0x7f, 0x90, 0x65, 0x58,
0x41, 0x1c, 0x82, 0xf0, 0x42, 0xc4, 0x8f, 0x40,
0x25, 0x5e, 0x2, 0x79, 0xb2, 0x63, 0x75, 0xa9,
0x3, 0xd9, 0x0, 0x58, 0x81, 0xfd, 0x68, 0x14,
0x7, 0xfc, 0xc0, 0x66, 0xc0, 0x7f, 0xca, 0x88,
0x80, 0xe0,
/* U+F0599 "" */
0x3, 0x89, 0x1, 0xfe, 0xfc, 0x7, 0xf1, 0xb4,
0x40, 0xc9, 0xb0, 0x27, 0x6, 0xc8, 0xc4, 0x7d,
0xae, 0x54, 0x2d, 0x8e, 0x5f, 0x96, 0x2d, 0x84,
0x42, 0x80, 0xa1, 0x40, 0x3f, 0xf8, 0x51, 0xa,
0x2, 0x85, 0x2, 0x67, 0x2f, 0xcb, 0x16, 0x84,
0x47, 0xda, 0xe5, 0x40, 0x9b, 0x2, 0x70, 0x6c,
0x80, 0xc6, 0xd1, 0x3, 0xfb, 0xf0, 0x1c,
/* U+F059D "" */
0x3, 0xcd, 0x1, 0xff, 0x79, 0x70, 0x1f, 0xeb,
0xf8, 0xb0, 0x3f, 0x90, 0x2, 0x7, 0x9b, 0xf5,
0x28, 0x32, 0x2, 0xdf, 0xa, 0x74, 0xc4, 0x6d,
0xea, 0x87, 0xe0, 0x82, 0xff, 0xf6, 0xe1, 0x5,
0x6f, 0xfb, 0x90, 0x80, 0xfe, 0x60, 0x56, 0xff,
0xb3, 0x1, 0xff, 0xf9, 0xd0, 0x3f, 0xce, 0xa6,
0x7, 0xf8, 0xb6, 0x80,
/* U+F059E "" */
0x3, 0x8b, 0x40, 0x7f, 0xa6, 0x97, 0x90, 0x3e,
0x4e, 0xfe, 0x5c, 0xe, 0x56, 0x92, 0x0, 0xa5,
0x1, 0x2a, 0x1f, 0x3, 0xb3, 0x23, 0xab, 0x10,
0x18, 0xb9, 0x89, 0x30, 0x3e, 0xdf, 0x82, 0x83,
0xff, 0xf0, 0x43, 0x5b, 0xfe, 0xe4, 0x20, 0x3f,
0x98, 0x15, 0xbf, 0xec, 0xc0, 0x7f, 0xfe, 0x74,
0xf, 0xf3, 0xa9, 0x81, 0xfe, 0x2d, 0xa0,
/* U+F05A8 "" */
0x3, 0xe5, 0x40, 0xff, 0xe1, 0x16, 0x7, 0xfb,
0x10, 0xf, 0x1, 0x48, 0x3, 0xc8, 0xf, 0x9f,
0x3, 0xb3, 0x17, 0xf9, 0x8c, 0xc0, 0xfb, 0xa0,
0x28, 0xc8, 0x1f, 0x40, 0x3d, 0x0, 0xed, 0x41,
0x3, 0xe2, 0x5a, 0x5, 0x80, 0xff, 0x15, 0xc4,
0x63, 0x1, 0xe2, 0x42, 0x30, 0x33, 0x40, 0x77,
0x3, 0xe4, 0x2c, 0x24, 0xf1, 0x40, 0x71, 0xa8,
0x3d, 0x90, 0x89, 0x80, 0xc7, 0xa0, 0xf, 0x1,
0x6c, 0x3, 0xff, 0x8c,
/* U+F05A9 "" */
0x3, 0x3b, 0xfe, 0xac, 0xf, 0x5f, 0x10, 0x19,
0x4f, 0x40, 0xba, 0xa, 0xef, 0xda, 0xa0, 0xb8,
0xa, 0xbd, 0x44, 0x1, 0x57, 0xaa, 0x1, 0x50,
0x66, 0xfd, 0xa1, 0x15, 0x1, 0x9e, 0x64, 0x1,
0x79, 0x81, 0xe4, 0x1e, 0xfd, 0x98, 0x40, 0x78,
0xf8, 0x40, 0x19, 0xc8, 0x1f, 0xd7, 0xf5, 0x3,
0xff, 0x80, 0xc0, 0x30, 0x3f, 0xf8, 0x1c, 0x7,
0x3, 0xff, 0x80, 0x64, 0x10, 0x3c,
/* U+F05F1 "" */
0x13, 0x6d, 0x48, 0x1c, 0xc9, 0xca, 0xbc, 0x7,
0x88, 0x13, 0x58, 0xe, 0x80, 0x45, 0xb5, 0x2,
0x68, 0x9, 0x9e, 0x80, 0xa0, 0x60, 0x12, 0x40,
0x28, 0x3, 0x7, 0xae, 0x2, 0x90, 0x28, 0x76,
0x80, 0xf4, 0x3, 0xfc, 0x58, 0x1f, 0xe4, 0x6,
0x26, 0x3, 0xf9, 0x3d, 0x0,
/* U+F05FA "" */
0x2, 0x77, 0xfa, 0xa0, 0x3b, 0x44, 0x8, 0x50,
0xd, 0x8a, 0xdf, 0x7b, 0x80, 0x89, 0xa, 0x40,
0x90, 0x40, 0x71, 0xbb, 0xf4, 0x77, 0x2, 0x43,
0x34, 0x43, 0x80, 0xb1, 0x43, 0xec, 0x81, 0x93,
0x10, 0xce, 0x7, 0x98, 0x22, 0x22, 0x7, 0x88,
0x13, 0xc0, 0x7f, 0xc4, 0xf, 0xfe, 0x3, 0x20,
0x7f, 0x15, 0x59, 0x3f, 0x30,
/* U+F0606 "" */
0x3, 0x99, 0x0, 0x90, 0xf, 0xbc, 0xe6, 0x5b,
0x1, 0xc8, 0x7c, 0x53, 0xf4, 0xf, 0xbf, 0x8f,
0x3, 0xfa, 0xd8, 0xf, 0xfe, 0x6d, 0xb0, 0x1f,
0xc4, 0x6f, 0xc0, 0x62, 0x42, 0x68, 0x36, 0x30,
0xf, 0x62, 0xad, 0x6f, 0x94, 0x12, 0x1e, 0x7f,
0xa3, 0x74, 0xf2, 0x35, 0x64, 0x6f, 0x34, 0xf4,
0x5, 0xf1, 0xeb, 0xf5, 0xd8, 0x64, 0x1d, 0x88,
/* U+F060C "" */
0x3, 0xf8, 0x81, 0xfe, 0xc8, 0xf, 0xfe, 0x74,
0x3, 0xfb, 0x20, 0x3f, 0x61, 0x80, 0xfb, 0x14,
0xdf, 0x0, 0x44, 0x39, 0x38, 0x2, 0x81, 0xff,
0xe4, 0x1c, 0x70, 0xf, 0xce, 0x30, 0x3f, 0x9f,
0x3, 0xc0,
/* U+F064A "" */
0x48, 0x7, 0x91, 0x3, 0x5a, 0x40, 0x4b, 0xdc,
0xc0, 0xe2, 0x5, 0x40, 0xa0, 0x12, 0x14, 0xf,
0xc4, 0x7, 0x5, 0x0, 0x20, 0x44, 0x80, 0x22,
0x2a, 0x1d, 0x3, 0xc0, 0xd8, 0x8b, 0x5, 0xf8,
0x81, 0xd9, 0x7, 0xbe, 0xc8, 0x80, 0xea, 0x6,
0x24, 0xee, 0x20, 0x7f, 0xf0, 0xf, 0x3, 0xff,
0x8d, 0xff, 0xf6,
/* U+F067E "" */
0x3, 0xc5, 0x32, 0x7, 0xfd, 0x35, 0x9a, 0x81,
0xfd, 0x1d, 0xfd, 0x9d, 0x3, 0xce, 0xbc, 0x80,
0x1c, 0x88, 0x1a, 0x40, 0x64, 0xe, 0x51, 0x0,
0x2e, 0xd4, 0x3, 0xd9, 0x5a, 0xc, 0x20, 0x24,
0xc8, 0x7, 0xea, 0x2c, 0x20, 0x2b, 0x8, 0x19,
0x6, 0x55, 0x21, 0x88, 0x6, 0x58, 0x21, 0x61,
0x14, 0x52, 0x54, 0x77, 0x80, 0x98, 0x4, 0x59,
0xe9, 0x2d, 0x10, 0x3d, 0x1c, 0x24, 0x38, 0x1f,
0xe2, 0x70, 0xc0, 0x7f, 0xa0, 0xd, 0x8c, 0xc,
/* U+F067F "" */
0x3, 0xc5, 0xb1, 0x3, 0xfe, 0xba, 0x46, 0x80,
0x7f, 0x47, 0xbf, 0x56, 0xc0, 0x79, 0xd7, 0xc8,
0x5, 0x60, 0x1d, 0x20, 0x32, 0x6, 0x42, 0x10,
0x5, 0xda, 0x80, 0x79, 0x3d, 0x3, 0x8, 0x9,
0x1, 0xaf, 0xac, 0xb0, 0x91, 0x9a, 0x40, 0xe4,
0x19, 0x7c, 0x4e, 0x1b, 0x1, 0x3c, 0x10, 0x95,
0xa2, 0x2c, 0x14, 0xd7, 0x80, 0x96, 0x40, 0x1f,
0x49, 0xf5, 0x20, 0x4b, 0x60, 0x6c, 0xb8, 0x24,
0x7, 0x8a, 0x12, 0xbc, 0x9, 0x1, 0xf3, 0xe1,
0x17, 0xb0, 0xc,
/* U+F068A "" */
0x3, 0x89, 0x1, 0xf8, 0xdd, 0x94, 0x81, 0x96,
0xc4, 0x1, 0x6c, 0x43, 0x52, 0x7, 0x8d, 0xc4,
0xd, 0x58, 0x18, 0x81, 0xb2, 0x94, 0xf, 0x1e,
0x40, 0x2c, 0x40, 0xcc, 0x81, 0xcc, 0xc, 0x98,
0x44, 0x34, 0xa, 0x3, 0x54, 0x6, 0x7c, 0x6,
0x43, 0x2c, 0x3, 0xa2, 0x1d, 0xa, 0xb0, 0x50,
0x80, 0x7e, 0xe0, 0x15, 0x3, 0xd8, 0x81, 0x2c,
0x40, 0x2e, 0x40, 0xe3, 0xb3, 0xd0, 0x30,
/* U+F06A1 "" */
0x3, 0xd5, 0x1, 0xff, 0x65, 0x58, 0x1f, 0x8e,
0x1e, 0x48, 0xf, 0x1c, 0x30, 0x75, 0xc0, 0x32,
0xcb, 0x1, 0x2a, 0xe8, 0x5, 0x46, 0x3, 0x90,
0x58, 0x2e, 0x41, 0xff, 0x0, 0x98, 0xf, 0xa3,
0x3, 0xff, 0x80, 0xf8, 0x1f, 0xfc, 0xb9, 0x80,
0xdc, 0xf, 0x4b, 0x60, 0xad, 0x90, 0x0,
/* U+F06A5 "" */
0x16, 0x80, 0x5a, 0x3, 0xfc, 0xd9, 0x23, 0x61,
0x89, 0x5a, 0x25, 0x88, 0x1e, 0x20, 0x7f, 0xf3,
0x30, 0x1e, 0xc7, 0x1, 0xb1, 0x5, 0x0, 0x44,
0xf, 0xe0,
/* U+F06B5 "" */
0x2, 0xbf, 0xea, 0x7, 0x90, 0x19, 0x1, 0xcc,
0xf, 0x30, 0x35, 0x3, 0xd4, 0x8, 0x90, 0x1e,
0x24, 0x1, 0x1, 0xf9, 0x0, 0xa0, 0x7e, 0xa0,
0x90, 0x1f, 0x89, 0xb6, 0xff, 0x10, 0x4e, 0xb4,
0x4e, 0x3, 0xc4, 0x80, 0xff, 0xe3, 0xb7, 0xf8,
0xd, 0x24, 0x4a, 0x48, 0x0,
/* U+F06C0 "" */
0x9f, 0xff, 0xa3, 0x3, 0xfc, 0xc0, 0xeb, 0x40,
0x7f, 0xf4, 0xc9, 0x1, 0x89, 0x1, 0xa6, 0x20,
0xe, 0x80, 0x6a, 0xb3, 0x6c, 0xa8, 0x1d, 0x51,
0x25, 0x40, 0xfa, 0xa4, 0xa0, 0x7f, 0x5a, 0x3,
0x98, 0x1f, 0xe6,
/* U+F06C3 "" */
0x9f, 0xff, 0xa3, 0x3, 0xfc, 0xc0, 0xeb, 0x40,
0x7f, 0x54, 0x94, 0xf, 0xaa, 0x24, 0xa8, 0x1d,
0x56, 0x6d, 0x95, 0x3, 0x4c, 0x40, 0x1d, 0x0,
0xc4, 0x80, 0xc4, 0x80, 0xff, 0xe9, 0xda, 0x3,
0x98, 0x1f, 0xe6,
/* U+F06E8 "" */
0x3, 0xff, 0x96, 0xf8, 0x1f, 0xe2, 0x6, 0x20,
0x62, 0x6, 0x39, 0x80, 0x78, 0xb, 0x70, 0x31,
0x80, 0x15, 0xa8, 0x1, 0xf0, 0x39, 0xb5, 0xa4,
0x8f, 0x9a, 0x40, 0xf3, 0x40, 0x77, 0x3, 0x9b,
0xc, 0x7, 0x89, 0x6, 0x84, 0xa0, 0x7f, 0x8c,
0xe3, 0xe0, 0x40, 0xf8, 0x97, 0xa0, 0x68, 0x7,
0xa0, 0x1f, 0xdc, 0xd, 0x18, 0x1f, 0xe2, 0x4,
0x80, 0xff, 0xbc, 0x8a, 0x40, 0xff, 0x8c, 0x8c,
0x7, 0xff, 0x6, 0xd4, 0x3, 0xc0,
/* U+F070D "" */
0x3, 0x93, 0x62, 0x7, 0xe9, 0xec, 0x8d, 0xd8,
0x1d, 0x1c, 0xff, 0x48, 0x40, 0x4a, 0x75, 0x7f,
0x47, 0xd2, 0x5, 0x49, 0x64, 0x85, 0xe0, 0xa8,
0xc4, 0xb8, 0xc, 0xc1, 0x88, 0x22, 0x81, 0x1,
0x10, 0x4, 0xe, 0x3, 0xff, 0x84, 0x50, 0x20,
0x79, 0x3, 0xb0, 0x94, 0x70, 0xaa, 0xa2, 0x9,
0xf, 0x51, 0xea, 0xa8, 0xac, 0x7, 0x34, 0xe,
0x38, 0xc0, 0x7, 0x3f, 0x64, 0x5c, 0x30, 0x18,
0xe8, 0x12, 0xb, 0x80, 0x80,
/* U+F070E "" */
0x3, 0xed, 0x80, 0x7f, 0x22, 0x48, 0xf, 0xc9,
0xc4, 0x7, 0xcf, 0xa6, 0x7, 0xa7, 0x80, 0xc0,
0x3c, 0xd9, 0x0, 0x68, 0xf, 0x66, 0x1, 0x5a,
0x40, 0x44, 0x10, 0xad, 0xc, 0x5, 0x98, 0x6,
0x15, 0x80, 0x66, 0x19, 0xc0, 0x6f, 0xd6, 0x9,
0x4, 0xd, 0xa1, 0x8, 0x10, 0x38, 0xb9, 0xa8,
0x1f, 0xfc, 0xd5, 0x40, 0x80,
/* U+F0717 "" */
0x3, 0x89, 0x20, 0x3f, 0xd7, 0x52, 0x7, 0x90,
0x8, 0x19, 0x4, 0x80, 0x1a, 0x40, 0xb8, 0x9,
0x0, 0x38, 0xea, 0x88, 0xd9, 0x23, 0xa, 0xba,
0xeb, 0x93, 0x11, 0x15, 0x11, 0x42, 0xdc, 0x80,
0xff, 0xe1, 0x45, 0x44, 0x50, 0xb7, 0x20, 0xab,
0xae, 0xb9, 0x31, 0x1c, 0x75, 0x44, 0x6e, 0x4c,
0x1a, 0x40, 0xb8, 0xb, 0x0, 0x90, 0x8, 0x19,
0x4, 0x80, 0xf5, 0xd0, 0x81, 0x80,
/* U+F072A "" */
0x9, 0xbf, 0xc8, 0x1b, 0x27, 0xea, 0x58, 0xe7,
0x90, 0x39, 0x80, 0xe7, 0x90, 0x3f, 0xc5, 0xb1,
0x3, 0xe9, 0xa4, 0x68, 0x7, 0x36, 0x3, 0x36,
0x3, 0x50, 0x36, 0x74, 0xc, 0x40, 0xb1, 0xe4,
0xc, 0x40, 0x62, 0x39, 0x3, 0x51, 0x8, 0x4e,
0x81, 0x9a, 0x9f, 0xaa, 0x60, 0x75, 0xd2, 0x35,
0x2, 0x48, 0x0, 0xb6, 0x20, 0x12, 0x0,
/* U+F075A "" */
0x3, 0xf8, 0xbb, 0xc0, 0xc5, 0xcd, 0xf4, 0x40,
0x65, 0xa3, 0x20, 0xb6, 0x3, 0xce, 0x6f, 0xa6,
0x3, 0xd1, 0x90, 0x3f, 0xf9, 0xf7, 0xd0, 0xa,
0x70, 0x33, 0x40, 0x4a, 0xb4, 0x6, 0xe0, 0x6c,
0x7, 0xd8, 0x9, 0x70, 0x22, 0x4, 0xab, 0x95,
0xa0, 0x78, 0x19, 0x46, 0x0,
/* U+F075F "" */
0x3, 0xff, 0x8d, 0x80, 0xff, 0xb1, 0x3, 0xfd,
0x88, 0x12, 0x0, 0x87, 0xf1, 0x2, 0x55, 0xb5,
0x40, 0x7c, 0xa4, 0xc8, 0xf, 0xfe, 0x42, 0x93,
0x2f, 0xe2, 0x4, 0xab, 0x6a, 0x80, 0xb1, 0x2,
0x40, 0x10, 0x1d, 0x88, 0x1f, 0xfc, 0xc, 0x7,
0xc0,
/* U+F0769 "" */
0x3, 0x91, 0x3, 0xfd, 0x50, 0x1f, 0xfd, 0x33,
0xf8, 0x4f, 0x40, 0xe8, 0x7, 0x22, 0x4, 0x50,
0x1e, 0x80, 0x50, 0xf, 0x91, 0x5, 0x1, 0xfa,
0x0, 0xb7, 0xfb, 0x82, 0x94, 0x6d, 0x25, 0x80,
0xe7, 0x70, 0x1c,
/* U+F07AE "" */
0x3, 0xfd, 0x20, 0xf, 0xf3, 0xed, 0xc0, 0x7c,
0xb4, 0x2, 0x80, 0x71, 0xb4, 0x40, 0xe4, 0x6,
0xc8, 0xf, 0x34, 0x7, 0xfd, 0xa0, 0x5f, 0xa4,
0x1, 0xfc, 0x80, 0x34, 0x81, 0xb0, 0x64, 0xa,
0x81, 0x5f, 0x20, 0x50, 0x32, 0x34, 0x81, 0xdb,
0xf5, 0x1, 0x90, 0x1d, 0xad, 0xa0,
/* U+F081B "" */
0x3, 0x8f, 0xfe, 0x60, 0x7a, 0x9b, 0x72, 0xa0,
0x7e, 0x4b, 0x10, 0x3f, 0xfb, 0x65, 0x1, 0xff,
0xc0, 0x5c, 0xf, 0xfe, 0x3, 0xa0, 0x7f, 0xf4,
0xd2, 0xe2, 0x12, 0xc4, 0x1b, 0x79, 0x1b, 0x72,
0x28,
/* U+F081C "" */
0x3, 0xe2, 0x78, 0xf, 0x8f, 0xdb, 0xa0, 0x3b,
0x70, 0xff, 0x34, 0x0, 0x9c, 0x7, 0xb8, 0x1f,
0xfd, 0x4b, 0x0, 0xff, 0xe0, 0x1e, 0x7, 0xff,
0x2, 0x30, 0x3f, 0xfb, 0x48, 0xf, 0x25, 0xb0,
0x34, 0xf, 0x5b, 0x91, 0x40,
/* U+F08DD "" */
0x6, 0xda, 0x1, 0x54, 0xa6, 0x4, 0x80, 0xcc,
0x12, 0x3, 0x60, 0x80, 0xe4, 0x1f, 0xfe, 0x3,
0x76, 0x7, 0xff, 0x81, 0xb0, 0xcc, 0x80, 0xb0,
0x28, 0x80,
/* U+F0917 "" */
0x9, 0xbf, 0xc8, 0x1b, 0x27, 0xea, 0x58, 0xc7,
0x10, 0x39, 0x80, 0xc7, 0x10, 0x3f, 0xc5, 0xb1,
0x3, 0xe9, 0xa4, 0x68, 0x7, 0x31, 0x5, 0x4d,
0x80, 0xd7, 0xa0, 0xc8, 0xa0, 0x63, 0xb, 0xb0,
0x90, 0x18, 0x89, 0xc, 0xd2, 0x6, 0xa1, 0x20,
0xbe, 0x81, 0x9a, 0x34, 0x32, 0xc0, 0xeb, 0xa4,
0x6a, 0x4, 0x90, 0x1, 0x6c, 0x40, 0x24,
/* U+F091C "" */
0x3, 0xff, 0x89, 0xfc, 0x80, 0xf3, 0x2, 0xe0,
0x7a, 0x81, 0x22, 0x6, 0x44, 0xd, 0x40, 0xdc,
0xe, 0x60, 0x45, 0x93, 0xe6, 0x59, 0xda, 0xbf,
0x63, 0x68, 0x6, 0x8c, 0xe, 0x6f, 0x1, 0xf5,
0xb8, 0x81, 0xed, 0xb9, 0x1, 0x88, 0x1f, 0xc0,
/* U+F0957 "" */
0x3, 0xc5, 0xb1, 0x3, 0xfe, 0xd9, 0x23, 0x60,
0x1f, 0xdc, 0x6f, 0xd8, 0x60, 0x3c, 0xf0, 0xc4,
0x1, 0xc6, 0x1, 0xb4, 0x74, 0xf, 0x36, 0x40,
0x29, 0xf5, 0x1, 0xec, 0x6e, 0xa, 0x1, 0xfc,
0xb7, 0x14, 0xf, 0xcb, 0x7a, 0x45, 0x49, 0x40,
0xe5, 0x54, 0x7c, 0x71, 0xe, 0x69, 0x7, 0x51,
0xf2, 0x5e, 0x1c, 0xe5, 0xa0, 0x3e, 0x6e, 0x6,
0xff, 0xe, 0xa3, 0xe1, 0x1, 0xfc, 0xaa, 0x8c,
0x50, 0x3f, 0xcb, 0x7b, 0x95, 0x3, 0xff, 0x82,
0x74, 0x0,
/* U+F095F "" */
0x3, 0x10, 0x3f, 0x3d, 0x14, 0x40, 0x79, 0xd7,
0x50, 0x16, 0x3, 0x24, 0x0, 0x92, 0x81, 0x78,
0xd, 0x49, 0x5, 0x39, 0xe1, 0x43, 0xa9, 0xae,
0x7, 0x20, 0x28, 0x80, 0xfe, 0xa2, 0x81, 0xfa,
0xa4, 0x3, 0xe4, 0xe8, 0x1e, 0x2f, 0x8a, 0xd8,
0x80, 0x76, 0x8b, 0xb4, 0xc0,
/* U+F096B "" */
0x0, 0x5b, 0x1, 0x16, 0xc0, 0x69, 0xa4, 0x75,
0x34, 0x8e, 0x82, 0x77, 0xf4, 0xae, 0xfe, 0x74,
0xf4, 0x87, 0x40, 0x17, 0x18, 0x17, 0x81, 0x38,
0x2, 0x6, 0x2a, 0x42, 0x1d, 0x69, 0xb6, 0x41,
0x10, 0x3d, 0xe8, 0x1f, 0xdf, 0xd7, 0x7f, 0x1,
0xea, 0x7, 0x1a, 0x7, 0x95, 0x3, 0x74, 0x7,
0xca, 0x0, 0xa4, 0xf, 0xfe, 0x32, 0xff, 0x40,
0x17, 0xfc, 0x53, 0x27, 0xfd, 0x48,
/* U+F099D "" */
0x3, 0x92, 0x1, 0xf9, 0xeb, 0x59, 0x81, 0xa7,
0x84, 0x1, 0x9e, 0xe, 0xc0, 0xfc, 0xf8, 0x1c,
0xd8, 0xf, 0xea, 0x2, 0x81, 0xf9, 0xbc, 0x7,
0xc8, 0xec, 0x28, 0x8, 0x80, 0xe0, 0x90, 0xe0,
0xa, 0x3, 0xfc, 0xb0, 0x2, 0x6, 0x20, 0x2a,
0x41, 0x36, 0xd0, 0x22, 0x28, 0x2, 0x70, 0xa,
0x5, 0x88, 0x18, 0xe0, 0x31, 0xcc, 0x3, 0xc4,
0xf, 0x4f, 0xd0, 0xc,
/* U+F09A0 "" */
0x3, 0xfe, 0x68, 0xf, 0xfb, 0x4a, 0xc0, 0xfd,
0x39, 0xaf, 0x1, 0xf1, 0x60, 0x30, 0x60, 0x7c,
0x7f, 0xa0, 0x1f, 0xfd, 0x2b, 0xff, 0xfc, 0xc4,
0xe, 0xdf, 0xd0, 0x42, 0x3a, 0x5f, 0x88, 0x41,
0xc2, 0x7, 0x8c, 0x40, 0x22, 0xdf, 0xfb, 0xa,
0x5, 0xc5, 0xbe, 0x34, 0xe, 0x69, 0x7a, 0x81,
0x0,
/* U+F09AB "" */
0x3, 0xeb, 0xb4, 0xc0, 0xf2, 0x4b, 0x4e, 0x1,
0xf8, 0xde, 0x7, 0xf8, 0x81, 0xfe, 0x5c, 0xf,
0xfe, 0x77, 0xfe, 0xa3, 0xf5, 0x8, 0xdb, 0xf8,
0x97, 0x21, 0x2f, 0x8d, 0x4e, 0xb0, 0x3b, 0x16,
0x24, 0xb9, 0x1, 0xcf, 0x2, 0x7c, 0x46, 0xc2,
0x90, 0x38, 0xbb, 0x44, 0x8,
/* U+F0A70 "" */
0x64, 0x98, 0x64, 0xc, 0xe3, 0x50, 0x54, 0x1,
0x78, 0x7, 0xe3, 0x40, 0xff, 0x30, 0x3f, 0xf8,
0x92, 0x8c, 0x40, 0xf2, 0x24, 0x8, 0x60, 0x75,
0x60, 0xd, 0x3, 0xe8, 0xc6, 0x40, 0x1b, 0x10,
0x3f, 0x8c, 0x60, 0x7f, 0xf7, 0x8, 0x1e, 0x24,
/* U+F0A7A "" */
0x9, 0x5b, 0xf9, 0xa4, 0x22, 0xd8, 0x81, 0x4b,
0x61, 0xf, 0xfe, 0x86, 0x1, 0xab, 0x18, 0x81,
0xf3, 0xe0, 0x81, 0xff, 0xec, 0xd0, 0x72, 0x7,
0x14, 0xbd, 0x80, 0x90, 0xb7, 0xca, 0x80,
/* U+F0AAC "" */
0x9, 0xbf, 0xc8, 0x1b, 0x27, 0xea, 0x58, 0xc7,
0x10, 0x39, 0x80, 0xc7, 0x10, 0x3f, 0x5b, 0xf8,
0xc, 0x97, 0xe0, 0x3e, 0x70, 0xf, 0xf4, 0x60,
0x7f, 0x40, 0x10, 0xf, 0xc4, 0x1, 0x3, 0xf7,
0x1, 0xc0, 0xfc, 0xbf, 0x20, 0x3c, 0xdf, 0xe0,
0x9, 0x2d, 0xfc, 0x90,
/* U+F0AD7 "" */
0x7f, 0xff, 0xd8, 0x50, 0xc8, 0x81, 0x30, 0xc9,
0x30, 0x12, 0x86, 0x35, 0x11, 0x1, 0x97, 0x4,
0x76, 0x11, 0x3, 0x56, 0x30, 0x74, 0x54, 0x4,
0xad, 0xff, 0x0, 0x5d, 0x2f, 0xf3, 0x20,
/* U+F0C99 "" */
0xd, 0xff, 0xc8, 0x69, 0x6f, 0xd2, 0x55, 0x9,
0xb7, 0xd0, 0x70, 0x40, 0xf9, 0xf0, 0x1c, 0xf,
0xfe, 0xb, 0x3, 0xff, 0x83, 0x80, 0xff, 0xe0,
0xd0, 0x3f, 0x9f, 0x3, 0xd9, 0xbf, 0xb0, 0x11,
0xae, 0xdf, 0x99, 0x24, 0x80,
/* U+F0F5F "" */
0x9, 0xbf, 0xfe, 0x2, 0x6, 0xc9, 0xff, 0xc0,
0xa5, 0x8f, 0xff, 0xf8, 0x1, 0x81, 0xff, 0xd2,
0x6c, 0x7, 0xf4, 0xfd, 0x7b, 0x3, 0xfc, 0x44,
0xa8, 0x30, 0x3f, 0xe9, 0x50, 0x1f, 0xfc, 0x1b,
0x4c, 0xc, 0x97, 0x80, 0x59, 0xc2, 0x8, 0xdb,
0xe0, 0xc, 0x87, 0x80, 0x6f, 0xf5, 0x2, 0x20,
0xf, 0x3, 0xcb, 0x81, 0x5c, 0xf3, 0x3, 0xd9,
0x0, 0xcb, 0x9c, 0x58,
/* U+F0FC6 "" */
0x3, 0xfc, 0x88, 0x1f, 0xf2, 0xf7, 0x60, 0x1f,
0xea, 0xbe, 0x14, 0xf, 0xc8, 0x50, 0x62, 0x3,
0xf1, 0x3, 0x30, 0x26, 0xfd, 0x83, 0x20, 0xb1,
0xa4, 0xf2, 0x13, 0x80, 0x80, 0x7f, 0xc4, 0xf,
0xfe, 0x5c, 0xf4, 0xf, 0xfe, 0x2, 0xc, 0xf,
0xfe, 0x7, 0x7c, 0xf, 0xfe, 0x1, 0x84, 0xf,
0xfe, 0x5d, 0x27, 0xfa, 0x1, 0x80,
/* U+F1011 "" */
0x76, 0xff, 0xf0, 0xc, 0x4b, 0xff, 0x84, 0x7,
0xff, 0x0, 0xd6, 0x7, 0xfb, 0xa1, 0x2d, 0xc1,
0x5b, 0x80, 0xc9, 0x61, 0x92, 0xc0, 0x7d, 0x44,
0x40, 0x7f, 0x15, 0x57, 0x3, 0xf8, 0x8e, 0x88,
0x1f, 0xea, 0xd4, 0x3, 0x80,
/* U+F1020 "" */
0x3, 0xe9, 0x80, 0xff, 0xe0, 0x32, 0x40, 0x7f,
0x1a, 0x3, 0xa0, 0x26, 0x41, 0xb9, 0x0, 0x37,
0x21, 0x50, 0x2d, 0xbf, 0xd0, 0xb0, 0x39, 0x90,
0x38, 0x90, 0xc, 0xd8, 0x20, 0x36, 0x60, 0x4a,
0xd2, 0x3, 0x9e, 0x2, 0x9b, 0x38, 0x40, 0x44,
0x80, 0xfc, 0x40, 0x10, 0x80, 0x54, 0x4, 0xab,
0x68, 0x6, 0x64, 0xb, 0x99, 0xa, 0x1, 0xf9,
0x50, 0x11, 0x81, 0xfc, 0x90, 0xb0, 0x30,
/* U+F1054 "" */
0x3, 0x38, 0x80, 0xee, 0x86, 0x86, 0xc0, 0x3c,
0x8e, 0xb1, 0x81, 0xdb, 0x82, 0x8, 0x1e, 0x6a,
0x81, 0xfd, 0x7a, 0x1, 0x81, 0x3, 0xf5, 0x63,
0x30, 0x1d, 0x5, 0xd0, 0x14, 0xa0, 0x75, 0xbe,
0xe8, 0x9, 0x27, 0xb6, 0x9, 0x0, 0xff, 0xe8,
0x90, 0x3f, 0xe8, 0xd3, 0x40, 0x0,
/* U+F10AF "" */
0x1, 0x18, 0x1f, 0xfc, 0x9, 0x9, 0x80, 0xdf,
0xf3, 0x5, 0x59, 0x42, 0x36, 0xe5, 0x45, 0x29,
0xa, 0x21, 0x2c, 0x40, 0xff, 0xea, 0x56, 0xf2,
0x3, 0x14, 0x4, 0x64, 0xc0, 0x72, 0xe0, 0x7f,
0xf0, 0x5d, 0x3, 0xff, 0xac, 0x97, 0x70, 0x96,
0x20, 0x8b, 0x79, 0x8b, 0x72, 0x28,
/* U+F111C "" */
0x93, 0xff, 0x80, 0xdf, 0xff, 0x0, 0xf, 0xfe,
0x6, 0x49, 0xad, 0xd9, 0x26, 0x20, 0x25, 0xba,
0x0, 0x20, 0x52, 0xdd, 0x0, 0xf4, 0xb7, 0x40,
0x3d, 0x2d, 0xd0, 0xf, 0x4b, 0x74, 0x3, 0xd2,
0xdd, 0x0, 0xf4, 0xb7, 0x40, 0x34, 0x95, 0xba,
0x48, 0x0,
/* U+F111D "" */
0x72, 0x7f, 0xc0, 0x23, 0x7f, 0xf1, 0x3, 0xff,
0x87, 0xd9, 0xdb, 0xcc, 0xe2, 0x6, 0xbb, 0x6e,
0x0, 0xa2, 0x5, 0x6f, 0x40, 0x2a, 0x80, 0xad,
0xe8, 0x7, 0xeb, 0x7a, 0x1, 0xf8, 0xa5, 0xc0,
0x5d, 0x81, 0xff, 0xc0, 0x64, 0xf, 0xfe, 0x5,
0x42, 0x60, 0x3d, 0x30, 0xcc,
/* U+F111E "" */
0x4b, 0xff, 0x81, 0x6f, 0xff, 0x0, 0xf, 0xfe,
0x5, 0x25, 0x6f, 0x89, 0x54, 0xdb, 0xdb, 0xbb,
0x64, 0x5, 0x2d, 0xd0, 0xf, 0x14, 0xb1, 0x3,
0xff, 0xd1, 0x20, 0xf, 0x48, 0x0,
/* U+F11DB "" */
0x0, 0x9b, 0xff, 0x80, 0xd2, 0x2d, 0xa4, 0x5b,
0x48, 0x20, 0x67, 0xb5, 0xe, 0xd7, 0x3, 0xff,
0xd4, 0x9b, 0xb1, 0x6e, 0x80, 0x78, 0xdb, 0x21,
0x6c, 0xc0, 0xf3, 0xda, 0x87, 0x6b, 0x81, 0xff,
0xe8, 0xc5, 0xed, 0x43, 0xb5, 0xc6, 0x60, 0x80,
0x26, 0x0, 0x4c, 0x5, 0xc7, 0xff, 0xfc, 0x28,
/* U+F11E1 "" */
0x3, 0xc4, 0x80, 0xff, 0xa6, 0xc8, 0x7, 0x6f,
0xf3, 0x0, 0xff, 0xce, 0x21, 0x68, 0x80, 0x36,
0x8, 0x93, 0x4, 0x98, 0x96, 0x4c, 0x22, 0x7,
0x9b, 0x1, 0xf2, 0x80, 0x5f, 0x80, 0xb1, 0x1,
0xe2, 0x1, 0x68, 0x2, 0xcc, 0x22, 0x38, 0x60,
0x18, 0x82, 0xc, 0x1, 0xc, 0x3, 0x2, 0x0,
0xa0, 0x24, 0x80, 0x12, 0x1, 0x2d, 0xfc, 0xbf,
0xcb, 0x69, 0x80,
/* U+F11F3 "" */
0x2d, 0xfe, 0x44, 0xe, 0x72, 0xdf, 0x4b, 0xb0,
0x81, 0xdb, 0x7b, 0xf5, 0x19, 0x1, 0xa6, 0xc8,
0x7, 0x43, 0x48, 0x13, 0xb4, 0xe8, 0x15, 0xa2,
0x20, 0x15, 0x6d, 0x51, 0x1, 0xfd, 0x50, 0x12,
0x0, 0x83, 0x3, 0x90, 0x2c, 0x20, 0x8, 0x5d,
0xbb, 0x86, 0x55, 0x91, 0x53, 0x48, 0x4c, 0x1b,
0xb, 0x12, 0x4b, 0x25, 0x89, 0x68, 0x40,
/* U+F12A1 "" */
0x1, 0x6e, 0x0, 0x52, 0xf1, 0xd4, 0xd, 0x70,
0xbf, 0xea, 0x7, 0xff, 0x7c, 0x9c, 0x6, 0xdb,
0x1, 0x89, 0xc0, 0x5e, 0xdd, 0xc2, 0x76, 0xe6,
0x80,
/* U+F12A2 "" */
0x1, 0x6e, 0x0, 0x52, 0xf1, 0xd4, 0xd, 0x70,
0xbf, 0xea, 0x7, 0xff, 0x3f, 0xfc, 0x6, 0x27,
0x1, 0xb6, 0xc0, 0x6f, 0xf0, 0x18, 0x9c, 0x5,
0xed, 0xdc, 0x27, 0x6e, 0x68,
/* U+F12A3 "" */
0x1, 0x6e, 0x0, 0x49, 0x2c, 0x4b, 0x60, 0x1b,
0x60, 0x96, 0xe8, 0x0, 0xdb, 0x88, 0x11, 0x38,
0xd, 0xb6, 0x3, 0x7f, 0x80, 0xc4, 0xe0, 0x36,
0xd8, 0xd, 0xfe, 0x3, 0x13, 0x80, 0xbd, 0xbb,
0x84, 0xed, 0xcd, 0x0,
/* U+F12BA "" */
0xc, 0xf, 0xf9, 0x10, 0x17, 0xe8, 0xd2, 0x9c,
0xbe, 0xa0, 0x18, 0x17, 0x6e, 0x89, 0x2, 0x60,
0x20, 0x9, 0x98, 0xf, 0x80, 0x22, 0xb, 0xcb,
0x84, 0x42, 0x1, 0x64, 0x4, 0xce, 0x4, 0x6b,
0xc0, 0x26, 0x87, 0xe1, 0xb0, 0xf, 0x14, 0x5,
0xf8, 0xb4, 0x48, 0x10, 0x13, 0x81, 0x35, 0xf8,
0x1, 0x77, 0x84, 0x7b, 0x1, 0xb0, 0x80, 0xf5,
0x20, 0x9, 0xe0,
/* U+F12D3 "" */
0x3, 0x8c, 0x40, 0x7f, 0x2d, 0x8e, 0xf8, 0x40,
0x8c, 0xf4, 0x81, 0x9e, 0xc4, 0x33, 0x3, 0xf8,
0xd6, 0x15, 0xbf, 0xe0, 0x2d, 0x2d, 0xfc, 0x40,
0xd2, 0xdf, 0xc8, 0xd, 0x2d, 0xfc, 0x80, 0xd2,
0xdf, 0xc8, 0xd, 0x2d, 0xfc, 0x80, 0x55, 0x2d,
0xfc, 0xaa,
/* U+F12D4 "" */
0x3, 0x8c, 0x40, 0x7f, 0x2d, 0x8e, 0xf8, 0x40,
0x8c, 0xf4, 0x81, 0x9e, 0xc4, 0x33, 0x3, 0xf8,
0xd6, 0x15, 0xbf, 0xe0, 0x2d, 0x2d, 0xfc, 0x40,
0xd2, 0xdf, 0xc8, 0xc, 0x97, 0xf1, 0x3, 0xff,
0xa5, 0x50, 0x1f, 0xea, 0x80,
/* U+F139D "" */
0x3, 0xff, 0x91, 0xb9, 0x3, 0xfd, 0x9, 0x40,
0x3f, 0x8b, 0xbd, 0x21, 0x20, 0x3d, 0xca, 0x2a,
0xe2, 0x7, 0x9f, 0x11, 0x2, 0x7, 0xd4, 0x89,
0x5d, 0x2, 0x57, 0xf0, 0x19, 0x46, 0x40, 0x20,
0x22, 0x7, 0x1c, 0x40, 0x8a, 0x40, 0x38, 0x97,
0x5, 0x4a, 0xc0, 0xcc, 0x72, 0xba, 0x40, 0x3b,
0x60, 0x2a, 0x35, 0xfd, 0x45, 0x2b, 0xf2, 0x16,
0xf4, 0x10, 0x1b, 0x6c, 0x12, 0xc4, 0x1c, 0x96,
0x3, 0xf8, 0xc0, 0x30,
/* U+F140B "" */
0x3, 0xff, 0x80, 0xc0, 0xf2, 0xc0, 0x7a, 0x1,
0xe4, 0x40, 0xf4, 0x3, 0xc8, 0x85, 0xfb, 0x8,
0x7, 0x44, 0x40, 0xc5, 0x40, 0x3a, 0xd, 0xf9,
0x2, 0x80, 0xf4, 0x3, 0xc5, 0x1, 0xe8, 0x7,
0xb2, 0x3, 0xcc, 0xc
};
/*---------------------
* GLYPH DESCRIPTION
*--------------------*/
static const lv_font_fmt_txt_glyph_dsc_t glyph_dsc[] = {
{.bitmap_index = 0, .adv_w = 0, .box_w = 0, .box_h = 0, .ofs_x = 0, .ofs_y = 0} /* id = 0 reserved */,
{.bitmap_index = 0, .adv_w = 59, .box_w = 0, .box_h = 0, .ofs_x = 0, .ofs_y = 0},
{.bitmap_index = 0, .adv_w = 63, .box_w = 2, .box_h = 12, .ofs_x = 1, .ofs_y = 0},
{.bitmap_index = 8, .adv_w = 82, .box_w = 4, .box_h = 5, .ofs_x = 1, .ofs_y = 7},
{.bitmap_index = 15, .adv_w = 140, .box_w = 8, .box_h = 12, .ofs_x = 1, .ofs_y = 0},
{.bitmap_index = 52, .adv_w = 126, .box_w = 8, .box_h = 16, .ofs_x = 0, .ofs_y = -2},
{.bitmap_index = 97, .adv_w = 162, .box_w = 10, .box_h = 12, .ofs_x = 0, .ofs_y = 0},
{.bitmap_index = 140, .adv_w = 139, .box_w = 9, .box_h = 12, .ofs_x = 0, .ofs_y = 0},
{.bitmap_index = 180, .adv_w = 45, .box_w = 2, .box_h = 4, .ofs_x = 0, .ofs_y = 8},
{.bitmap_index = 183, .adv_w = 80, .box_w = 4, .box_h = 18, .ofs_x = 1, .ofs_y = -4},
{.bitmap_index = 209, .adv_w = 82, .box_w = 5, .box_h = 18, .ofs_x = 0, .ofs_y = -4},
{.bitmap_index = 240, .adv_w = 110, .box_w = 7, .box_h = 7, .ofs_x = 0, .ofs_y = 5},
{.bitmap_index = 257, .adv_w = 127, .box_w = 8, .box_h = 9, .ofs_x = 0, .ofs_y = 1},
{.bitmap_index = 277, .adv_w = 50, .box_w = 3, .box_h = 5, .ofs_x = 0, .ofs_y = -3},
{.bitmap_index = 283, .adv_w = 64, .box_w = 4, .box_h = 3, .ofs_x = 0, .ofs_y = 4},
{.bitmap_index = 288, .adv_w = 68, .box_w = 2, .box_h = 2, .ofs_x = 1, .ofs_y = 0},
{.bitmap_index = 290, .adv_w = 95, .box_w = 6, .box_h = 13, .ofs_x = 0, .ofs_y = -1},
{.bitmap_index = 317, .adv_w = 126, .box_w = 7, .box_h = 12, .ofs_x = 0, .ofs_y = 0},
{.bitmap_index = 339, .adv_w = 126, .box_w = 5, .box_h = 12, .ofs_x = 1, .ofs_y = 0},
{.bitmap_index = 349, .adv_w = 126, .box_w = 8, .box_h = 12, .ofs_x = 0, .ofs_y = 0},
{.bitmap_index = 383, .adv_w = 126, .box_w = 7, .box_h = 12, .ofs_x = 0, .ofs_y = 0},
{.bitmap_index = 416, .adv_w = 126, .box_w = 8, .box_h = 12, .ofs_x = 0, .ofs_y = 0},
{.bitmap_index = 445, .adv_w = 126, .box_w = 7, .box_h = 12, .ofs_x = 1, .ofs_y = 0},
{.bitmap_index = 474, .adv_w = 126, .box_w = 7, .box_h = 12, .ofs_x = 1, .ofs_y = 0},
{.bitmap_index = 507, .adv_w = 126, .box_w = 8, .box_h = 12, .ofs_x = 0, .ofs_y = 0},
{.bitmap_index = 536, .adv_w = 126, .box_w = 7, .box_h = 12, .ofs_x = 0, .ofs_y = 0},
{.bitmap_index = 568, .adv_w = 126, .box_w = 7, .box_h = 12, .ofs_x = 0, .ofs_y = 0},
{.bitmap_index = 601, .adv_w = 60, .box_w = 2, .box_h = 9, .ofs_x = 1, .ofs_y = 0},
{.bitmap_index = 607, .adv_w = 52, .box_w = 3, .box_h = 12, .ofs_x = 0, .ofs_y = -3},
{.bitmap_index = 619, .adv_w = 114, .box_w = 6, .box_h = 8, .ofs_x = 0, .ofs_y = 1},
{.bitmap_index = 637, .adv_w = 123, .box_w = 6, .box_h = 6, .ofs_x = 1, .ofs_y = 3},
{.bitmap_index = 648, .adv_w = 118, .box_w = 6, .box_h = 8, .ofs_x = 1, .ofs_y = 1},
{.bitmap_index = 666, .adv_w = 108, .box_w = 7, .box_h = 12, .ofs_x = 0, .ofs_y = 0},
{.bitmap_index = 694, .adv_w = 197, .box_w = 12, .box_h = 15, .ofs_x = 0, .ofs_y = -3},
{.bitmap_index = 756, .adv_w = 148, .box_w = 9, .box_h = 12, .ofs_x = 0, .ofs_y = 0},
{.bitmap_index = 793, .adv_w = 140, .box_w = 7, .box_h = 12, .ofs_x = 1, .ofs_y = 0},
{.bitmap_index = 823, .adv_w = 145, .box_w = 9, .box_h = 12, .ofs_x = 0, .ofs_y = 0},
{.bitmap_index = 856, .adv_w = 146, .box_w = 8, .box_h = 12, .ofs_x = 1, .ofs_y = 0},
{.bitmap_index = 885, .adv_w = 127, .box_w = 7, .box_h = 12, .ofs_x = 1, .ofs_y = 0},
{.bitmap_index = 908, .adv_w = 123, .box_w = 7, .box_h = 12, .ofs_x = 1, .ofs_y = 0},
{.bitmap_index = 927, .adv_w = 151, .box_w = 9, .box_h = 12, .ofs_x = 0, .ofs_y = 0},
{.bitmap_index = 964, .adv_w = 159, .box_w = 8, .box_h = 12, .ofs_x = 1, .ofs_y = 0},
{.bitmap_index = 980, .adv_w = 64, .box_w = 2, .box_h = 12, .ofs_x = 1, .ofs_y = 0},
{.bitmap_index = 984, .adv_w = 124, .box_w = 7, .box_h = 12, .ofs_x = 0, .ofs_y = 0},
{.bitmap_index = 999, .adv_w = 140, .box_w = 8, .box_h = 12, .ofs_x = 1, .ofs_y = 0},
{.bitmap_index = 1029, .adv_w = 122, .box_w = 7, .box_h = 12, .ofs_x = 1, .ofs_y = 0},
{.bitmap_index = 1037, .adv_w = 193, .box_w = 10, .box_h = 12, .ofs_x = 1, .ofs_y = 0},
{.bitmap_index = 1077, .adv_w = 159, .box_w = 8, .box_h = 12, .ofs_x = 1, .ofs_y = 0},
{.bitmap_index = 1104, .adv_w = 154, .box_w = 9, .box_h = 12, .ofs_x = 0, .ofs_y = 0},
{.bitmap_index = 1140, .adv_w = 142, .box_w = 8, .box_h = 12, .ofs_x = 1, .ofs_y = 0},
{.bitmap_index = 1166, .adv_w = 154, .box_w = 9, .box_h = 14, .ofs_x = 0, .ofs_y = -2},
{.bitmap_index = 1207, .adv_w = 136, .box_w = 8, .box_h = 12, .ofs_x = 1, .ofs_y = 0},
{.bitmap_index = 1239, .adv_w = 133, .box_w = 8, .box_h = 12, .ofs_x = 0, .ofs_y = 0},
{.bitmap_index = 1275, .adv_w = 133, .box_w = 8, .box_h = 12, .ofs_x = 0, .ofs_y = 0},
{.bitmap_index = 1286, .adv_w = 144, .box_w = 8, .box_h = 12, .ofs_x = 1, .ofs_y = 0},
{.bitmap_index = 1301, .adv_w = 144, .box_w = 9, .box_h = 12, .ofs_x = 0, .ofs_y = 0},
{.bitmap_index = 1339, .adv_w = 195, .box_w = 12, .box_h = 12, .ofs_x = 0, .ofs_y = 0},
{.bitmap_index = 1393, .adv_w = 141, .box_w = 9, .box_h = 12, .ofs_x = 0, .ofs_y = 0},
{.bitmap_index = 1430, .adv_w = 134, .box_w = 9, .box_h = 12, .ofs_x = 0, .ofs_y = 0},
{.bitmap_index = 1458, .adv_w = 134, .box_w = 8, .box_h = 12, .ofs_x = 0, .ofs_y = 0},
{.bitmap_index = 1487, .adv_w = 64, .box_w = 3, .box_h = 18, .ofs_x = 1, .ofs_y = -3},
{.bitmap_index = 1497, .adv_w = 95, .box_w = 6, .box_h = 13, .ofs_x = 0, .ofs_y = -1},
{.bitmap_index = 1523, .adv_w = 64, .box_w = 3, .box_h = 18, .ofs_x = 0, .ofs_y = -3},
{.bitmap_index = 1533, .adv_w = 95, .box_w = 6, .box_h = 6, .ofs_x = 0, .ofs_y = 6},
{.bitmap_index = 1547, .adv_w = 104, .box_w = 7, .box_h = 3, .ofs_x = 0, .ofs_y = -2},
{.bitmap_index = 1553, .adv_w = 79, .box_w = 4, .box_h = 3, .ofs_x = 0, .ofs_y = 10},
{.bitmap_index = 1558, .adv_w = 123, .box_w = 7, .box_h = 9, .ofs_x = 0, .ofs_y = 0},
{.bitmap_index = 1583, .adv_w = 126, .box_w = 7, .box_h = 12, .ofs_x = 1, .ofs_y = 0},
{.bitmap_index = 1608, .adv_w = 118, .box_w = 7, .box_h = 9, .ofs_x = 0, .ofs_y = 0},
{.bitmap_index = 1631, .adv_w = 127, .box_w = 7, .box_h = 12, .ofs_x = 0, .ofs_y = 0},
{.bitmap_index = 1655, .adv_w = 120, .box_w = 7, .box_h = 9, .ofs_x = 0, .ofs_y = 0},
{.bitmap_index = 1680, .adv_w = 81, .box_w = 5, .box_h = 14, .ofs_x = 0, .ofs_y = 0},
{.bitmap_index = 1696, .adv_w = 126, .box_w = 7, .box_h = 12, .ofs_x = 0, .ofs_y = -3},
{.bitmap_index = 1724, .adv_w = 124, .box_w = 6, .box_h = 12, .ofs_x = 1, .ofs_y = 0},
{.bitmap_index = 1739, .adv_w = 59, .box_w = 2, .box_h = 12, .ofs_x = 1, .ofs_y = 0},
{.bitmap_index = 1745, .adv_w = 57, .box_w = 4, .box_h = 15, .ofs_x = -1, .ofs_y = -3},
{.bitmap_index = 1758, .adv_w = 115, .box_w = 7, .box_h = 12, .ofs_x = 1, .ofs_y = 0},
{.bitmap_index = 1782, .adv_w = 59, .box_w = 2, .box_h = 12, .ofs_x = 1, .ofs_y = 0},
{.bitmap_index = 1786, .adv_w = 193, .box_w = 10, .box_h = 9, .ofs_x = 1, .ofs_y = 0},
{.bitmap_index = 1802, .adv_w = 124, .box_w = 6, .box_h = 9, .ofs_x = 1, .ofs_y = 0},
{.bitmap_index = 1812, .adv_w = 129, .box_w = 8, .box_h = 9, .ofs_x = 0, .ofs_y = 0},
{.bitmap_index = 1839, .adv_w = 126, .box_w = 7, .box_h = 12, .ofs_x = 1, .ofs_y = -3},
{.bitmap_index = 1865, .adv_w = 128, .box_w = 7, .box_h = 12, .ofs_x = 0, .ofs_y = -3},
{.bitmap_index = 1890, .adv_w = 78, .box_w = 4, .box_h = 10, .ofs_x = 1, .ofs_y = 0},
{.bitmap_index = 1899, .adv_w = 117, .box_w = 7, .box_h = 9, .ofs_x = 0, .ofs_y = 0},
{.bitmap_index = 1924, .adv_w = 76, .box_w = 5, .box_h = 11, .ofs_x = 0, .ofs_y = 0},
{.bitmap_index = 1939, .adv_w = 124, .box_w = 6, .box_h = 9, .ofs_x = 1, .ofs_y = 0},
{.bitmap_index = 1949, .adv_w = 110, .box_w = 7, .box_h = 9, .ofs_x = 0, .ofs_y = 0},
{.bitmap_index = 1973, .adv_w = 166, .box_w = 10, .box_h = 9, .ofs_x = 0, .ofs_y = 0},
{.bitmap_index = 2008, .adv_w = 112, .box_w = 7, .box_h = 9, .ofs_x = 0, .ofs_y = 0},
{.bitmap_index = 2031, .adv_w = 107, .box_w = 7, .box_h = 12, .ofs_x = 0, .ofs_y = -3},
{.bitmap_index = 2062, .adv_w = 112, .box_w = 7, .box_h = 9, .ofs_x = 0, .ofs_y = 0},
{.bitmap_index = 2084, .adv_w = 79, .box_w = 5, .box_h = 17, .ofs_x = 0, .ofs_y = -3},
{.bitmap_index = 2113, .adv_w = 63, .box_w = 2, .box_h = 14, .ofs_x = 1, .ofs_y = -2},
{.bitmap_index = 2117, .adv_w = 79, .box_w = 5, .box_h = 17, .ofs_x = 0, .ofs_y = -3},
{.bitmap_index = 2144, .adv_w = 151, .box_w = 9, .box_h = 4, .ofs_x = 0, .ofs_y = 3},
{.bitmap_index = 2158, .adv_w = 59, .box_w = 0, .box_h = 0, .ofs_x = 0, .ofs_y = 0},
{.bitmap_index = 2158, .adv_w = 59, .box_w = 2, .box_h = 12, .ofs_x = 1, .ofs_y = -3},
{.bitmap_index = 2166, .adv_w = 131, .box_w = 8, .box_h = 12, .ofs_x = 0, .ofs_y = 0},
{.bitmap_index = 2199, .adv_w = 96, .box_w = 4, .box_h = 5, .ofs_x = 1, .ofs_y = 7},
{.bitmap_index = 2208, .adv_w = 120, .box_w = 7, .box_h = 10, .ofs_x = 0, .ofs_y = 0},
{.bitmap_index = 2229, .adv_w = 84, .box_w = 5, .box_h = 7, .ofs_x = 0, .ofs_y = 5},
{.bitmap_index = 2243, .adv_w = 84, .box_w = 5, .box_h = 7, .ofs_x = 0, .ofs_y = 5},
{.bitmap_index = 2257, .adv_w = 128, .box_w = 6, .box_h = 12, .ofs_x = 1, .ofs_y = -3},
{.bitmap_index = 2274, .adv_w = 108, .box_w = 7, .box_h = 12, .ofs_x = 0, .ofs_y = -3},
{.bitmap_index = 2302, .adv_w = 148, .box_w = 9, .box_h = 15, .ofs_x = 0, .ofs_y = 0},
{.bitmap_index = 2346, .adv_w = 148, .box_w = 9, .box_h = 15, .ofs_x = 0, .ofs_y = 0},
{.bitmap_index = 2390, .adv_w = 148, .box_w = 9, .box_h = 15, .ofs_x = 0, .ofs_y = 0},
{.bitmap_index = 2435, .adv_w = 148, .box_w = 9, .box_h = 16, .ofs_x = 0, .ofs_y = 0},
{.bitmap_index = 2482, .adv_w = 148, .box_w = 9, .box_h = 15, .ofs_x = 0, .ofs_y = 0},
{.bitmap_index = 2528, .adv_w = 148, .box_w = 9, .box_h = 16, .ofs_x = 0, .ofs_y = 0},
{.bitmap_index = 2575, .adv_w = 208, .box_w = 14, .box_h = 12, .ofs_x = -1, .ofs_y = 0},
{.bitmap_index = 2625, .adv_w = 145, .box_w = 9, .box_h = 15, .ofs_x = 0, .ofs_y = -3},
{.bitmap_index = 2666, .adv_w = 127, .box_w = 7, .box_h = 15, .ofs_x = 1, .ofs_y = 0},
{.bitmap_index = 2696, .adv_w = 127, .box_w = 7, .box_h = 15, .ofs_x = 1, .ofs_y = 0},
{.bitmap_index = 2727, .adv_w = 127, .box_w = 7, .box_h = 15, .ofs_x = 1, .ofs_y = 0},
{.bitmap_index = 2758, .adv_w = 127, .box_w = 7, .box_h = 15, .ofs_x = 1, .ofs_y = 0},
{.bitmap_index = 2789, .adv_w = 64, .box_w = 4, .box_h = 15, .ofs_x = -1, .ofs_y = 0},
{.bitmap_index = 2799, .adv_w = 64, .box_w = 4, .box_h = 15, .ofs_x = 1, .ofs_y = 0},
{.bitmap_index = 2808, .adv_w = 64, .box_w = 6, .box_h = 15, .ofs_x = -1, .ofs_y = 0},
{.bitmap_index = 2820, .adv_w = 64, .box_w = 6, .box_h = 15, .ofs_x = -1, .ofs_y = 0},
{.bitmap_index = 2832, .adv_w = 150, .box_w = 9, .box_h = 12, .ofs_x = 0, .ofs_y = 0},
{.bitmap_index = 2867, .adv_w = 159, .box_w = 8, .box_h = 16, .ofs_x = 1, .ofs_y = 0},
{.bitmap_index = 2905, .adv_w = 154, .box_w = 9, .box_h = 16, .ofs_x = 0, .ofs_y = 0},
{.bitmap_index = 2951, .adv_w = 154, .box_w = 9, .box_h = 16, .ofs_x = 0, .ofs_y = 0},
{.bitmap_index = 2996, .adv_w = 154, .box_w = 9, .box_h = 16, .ofs_x = 0, .ofs_y = 0},
{.bitmap_index = 3043, .adv_w = 154, .box_w = 9, .box_h = 16, .ofs_x = 0, .ofs_y = 0},
{.bitmap_index = 3090, .adv_w = 154, .box_w = 9, .box_h = 15, .ofs_x = 0, .ofs_y = 0},
{.bitmap_index = 3136, .adv_w = 121, .box_w = 7, .box_h = 9, .ofs_x = 0, .ofs_y = 1},
{.bitmap_index = 3159, .adv_w = 154, .box_w = 9, .box_h = 13, .ofs_x = 0, .ofs_y = -1},
{.bitmap_index = 3204, .adv_w = 144, .box_w = 8, .box_h = 15, .ofs_x = 1, .ofs_y = 0},
{.bitmap_index = 3226, .adv_w = 144, .box_w = 8, .box_h = 15, .ofs_x = 1, .ofs_y = 0},
{.bitmap_index = 3248, .adv_w = 144, .box_w = 8, .box_h = 15, .ofs_x = 1, .ofs_y = 0},
{.bitmap_index = 3272, .adv_w = 144, .box_w = 8, .box_h = 15, .ofs_x = 1, .ofs_y = 0},
{.bitmap_index = 3296, .adv_w = 134, .box_w = 9, .box_h = 15, .ofs_x = 0, .ofs_y = 0},
{.bitmap_index = 3332, .adv_w = 132, .box_w = 7, .box_h = 12, .ofs_x = 1, .ofs_y = 0},
{.bitmap_index = 3356, .adv_w = 134, .box_w = 7, .box_h = 12, .ofs_x = 1, .ofs_y = 0},
{.bitmap_index = 3385, .adv_w = 123, .box_w = 7, .box_h = 12, .ofs_x = 0, .ofs_y = 0},
{.bitmap_index = 3416, .adv_w = 123, .box_w = 7, .box_h = 12, .ofs_x = 0, .ofs_y = 0},
{.bitmap_index = 3447, .adv_w = 123, .box_w = 7, .box_h = 12, .ofs_x = 0, .ofs_y = 0},
{.bitmap_index = 3479, .adv_w = 123, .box_w = 7, .box_h = 13, .ofs_x = 0, .ofs_y = 0},
{.bitmap_index = 3512, .adv_w = 123, .box_w = 7, .box_h = 12, .ofs_x = 0, .ofs_y = 0},
{.bitmap_index = 3545, .adv_w = 123, .box_w = 7, .box_h = 14, .ofs_x = 0, .ofs_y = 0},
{.bitmap_index = 3581, .adv_w = 187, .box_w = 12, .box_h = 9, .ofs_x = 0, .ofs_y = 0},
{.bitmap_index = 3622, .adv_w = 118, .box_w = 7, .box_h = 12, .ofs_x = 0, .ofs_y = -3},
{.bitmap_index = 3652, .adv_w = 120, .box_w = 7, .box_h = 12, .ofs_x = 0, .ofs_y = 0},
{.bitmap_index = 3683, .adv_w = 120, .box_w = 7, .box_h = 12, .ofs_x = 0, .ofs_y = 0},
{.bitmap_index = 3714, .adv_w = 120, .box_w = 7, .box_h = 12, .ofs_x = 0, .ofs_y = 0},
{.bitmap_index = 3746, .adv_w = 120, .box_w = 7, .box_h = 12, .ofs_x = 0, .ofs_y = 0},
{.bitmap_index = 3779, .adv_w = 60, .box_w = 4, .box_h = 12, .ofs_x = -1, .ofs_y = 0},
{.bitmap_index = 3789, .adv_w = 60, .box_w = 4, .box_h = 12, .ofs_x = 1, .ofs_y = 0},
{.bitmap_index = 3798, .adv_w = 60, .box_w = 5, .box_h = 12, .ofs_x = -1, .ofs_y = 0},
{.bitmap_index = 3809, .adv_w = 60, .box_w = 6, .box_h = 12, .ofs_x = -1, .ofs_y = 0},
{.bitmap_index = 3821, .adv_w = 132, .box_w = 8, .box_h = 13, .ofs_x = 0, .ofs_y = 0},
{.bitmap_index = 3857, .adv_w = 124, .box_w = 6, .box_h = 13, .ofs_x = 1, .ofs_y = 0},
{.bitmap_index = 3875, .adv_w = 129, .box_w = 8, .box_h = 12, .ofs_x = 0, .ofs_y = 0},
{.bitmap_index = 3909, .adv_w = 129, .box_w = 8, .box_h = 12, .ofs_x = 0, .ofs_y = 0},
{.bitmap_index = 3943, .adv_w = 129, .box_w = 8, .box_h = 12, .ofs_x = 0, .ofs_y = 0},
{.bitmap_index = 3978, .adv_w = 129, .box_w = 8, .box_h = 13, .ofs_x = 0, .ofs_y = 0},
{.bitmap_index = 4014, .adv_w = 129, .box_w = 8, .box_h = 12, .ofs_x = 0, .ofs_y = 0},
{.bitmap_index = 4050, .adv_w = 128, .box_w = 8, .box_h = 9, .ofs_x = 0, .ofs_y = 1},
{.bitmap_index = 4070, .adv_w = 128, .box_w = 8, .box_h = 11, .ofs_x = 0, .ofs_y = -1},
{.bitmap_index = 4104, .adv_w = 124, .box_w = 6, .box_h = 12, .ofs_x = 1, .ofs_y = 0},
{.bitmap_index = 4121, .adv_w = 124, .box_w = 6, .box_h = 12, .ofs_x = 1, .ofs_y = 0},
{.bitmap_index = 4138, .adv_w = 124, .box_w = 6, .box_h = 12, .ofs_x = 1, .ofs_y = 0},
{.bitmap_index = 4155, .adv_w = 124, .box_w = 6, .box_h = 12, .ofs_x = 1, .ofs_y = 0},
{.bitmap_index = 4172, .adv_w = 107, .box_w = 7, .box_h = 15, .ofs_x = 0, .ofs_y = -3},
{.bitmap_index = 4210, .adv_w = 130, .box_w = 7, .box_h = 15, .ofs_x = 1, .ofs_y = -3},
{.bitmap_index = 4238, .adv_w = 107, .box_w = 7, .box_h = 15, .ofs_x = 0, .ofs_y = -3},
{.bitmap_index = 4277, .adv_w = 151, .box_w = 9, .box_h = 15, .ofs_x = 0, .ofs_y = 0},
{.bitmap_index = 4323, .adv_w = 126, .box_w = 7, .box_h = 15, .ofs_x = 0, .ofs_y = -3},
{.bitmap_index = 4357, .adv_w = 64, .box_w = 2, .box_h = 15, .ofs_x = 1, .ofs_y = 0},
{.bitmap_index = 4363, .adv_w = 60, .box_w = 2, .box_h = 9, .ofs_x = 1, .ofs_y = 0},
{.bitmap_index = 4367, .adv_w = 212, .box_w = 12, .box_h = 12, .ofs_x = 0, .ofs_y = 0},
{.bitmap_index = 4408, .adv_w = 199, .box_w = 12, .box_h = 9, .ofs_x = 0, .ofs_y = 0},
{.bitmap_index = 4450, .adv_w = 133, .box_w = 8, .box_h = 15, .ofs_x = 0, .ofs_y = -3},
{.bitmap_index = 4494, .adv_w = 117, .box_w = 7, .box_h = 12, .ofs_x = 0, .ofs_y = -3},
{.bitmap_index = 4526, .adv_w = 133, .box_w = 8, .box_h = 16, .ofs_x = 0, .ofs_y = 0},
{.bitmap_index = 4572, .adv_w = 117, .box_w = 7, .box_h = 12, .ofs_x = 0, .ofs_y = 0},
{.bitmap_index = 4604, .adv_w = 134, .box_w = 8, .box_h = 15, .ofs_x = 0, .ofs_y = 0},
{.bitmap_index = 4642, .adv_w = 112, .box_w = 7, .box_h = 12, .ofs_x = 0, .ofs_y = 0},
{.bitmap_index = 4672, .adv_w = 144, .box_w = 8, .box_h = 12, .ofs_x = 1, .ofs_y = 0},
{.bitmap_index = 4706, .adv_w = 86, .box_w = 4, .box_h = 4, .ofs_x = 1, .ofs_y = 4},
{.bitmap_index = 4712, .adv_w = 126, .box_w = 8, .box_h = 12, .ofs_x = 0, .ofs_y = 0},
{.bitmap_index = 4746, .adv_w = 256, .box_w = 12, .box_h = 12, .ofs_x = 2, .ofs_y = 0},
{.bitmap_index = 4786, .adv_w = 256, .box_w = 12, .box_h = 17, .ofs_x = 2, .ofs_y = -2},
{.bitmap_index = 4862, .adv_w = 256, .box_w = 16, .box_h = 13, .ofs_x = 0, .ofs_y = 0},
{.bitmap_index = 4920, .adv_w = 256, .box_w = 12, .box_h = 12, .ofs_x = 2, .ofs_y = 0},
{.bitmap_index = 4953, .adv_w = 256, .box_w = 12, .box_h = 12, .ofs_x = 2, .ofs_y = 0},
{.bitmap_index = 4990, .adv_w = 256, .box_w = 12, .box_h = 12, .ofs_x = 2, .ofs_y = 0},
{.bitmap_index = 5027, .adv_w = 256, .box_w = 12, .box_h = 12, .ofs_x = 2, .ofs_y = 0},
{.bitmap_index = 5059, .adv_w = 256, .box_w = 8, .box_h = 14, .ofs_x = 4, .ofs_y = -1},
{.bitmap_index = 5077, .adv_w = 256, .box_w = 12, .box_h = 15, .ofs_x = 2, .ofs_y = -2},
{.bitmap_index = 5120, .adv_w = 256, .box_w = 14, .box_h = 14, .ofs_x = 1, .ofs_y = -1},
{.bitmap_index = 5161, .adv_w = 256, .box_w = 9, .box_h = 14, .ofs_x = 3, .ofs_y = -1},
{.bitmap_index = 5205, .adv_w = 256, .box_w = 12, .box_h = 14, .ofs_x = 2, .ofs_y = 0},
{.bitmap_index = 5245, .adv_w = 256, .box_w = 12, .box_h = 12, .ofs_x = 2, .ofs_y = -1},
{.bitmap_index = 5287, .adv_w = 256, .box_w = 10, .box_h = 16, .ofs_x = 3, .ofs_y = -2},
{.bitmap_index = 5312, .adv_w = 256, .box_w = 12, .box_h = 10, .ofs_x = 2, .ofs_y = 1},
{.bitmap_index = 5345, .adv_w = 256, .box_w = 8, .box_h = 6, .ofs_x = 4, .ofs_y = 3},
{.bitmap_index = 5362, .adv_w = 256, .box_w = 6, .box_h = 8, .ofs_x = 5, .ofs_y = 2},
{.bitmap_index = 5379, .adv_w = 256, .box_w = 6, .box_h = 8, .ofs_x = 5, .ofs_y = 2},
{.bitmap_index = 5395, .adv_w = 256, .box_w = 8, .box_h = 6, .ofs_x = 4, .ofs_y = 3},
{.bitmap_index = 5413, .adv_w = 256, .box_w = 14, .box_h = 14, .ofs_x = 1, .ofs_y = -1},
{.bitmap_index = 5479, .adv_w = 256, .box_w = 10, .box_h = 10, .ofs_x = 3, .ofs_y = 1},
{.bitmap_index = 5514, .adv_w = 256, .box_w = 14, .box_h = 12, .ofs_x = 1, .ofs_y = 0},
{.bitmap_index = 5556, .adv_w = 256, .box_w = 4, .box_h = 12, .ofs_x = 6, .ofs_y = 0},
{.bitmap_index = 5575, .adv_w = 256, .box_w = 16, .box_h = 12, .ofs_x = 0, .ofs_y = 0},
{.bitmap_index = 5629, .adv_w = 256, .box_w = 14, .box_h = 14, .ofs_x = 1, .ofs_y = -1},
{.bitmap_index = 5691, .adv_w = 256, .box_w = 10, .box_h = 13, .ofs_x = 3, .ofs_y = -1},
{.bitmap_index = 5737, .adv_w = 256, .box_w = 10, .box_h = 14, .ofs_x = 3, .ofs_y = -1},
{.bitmap_index = 5775, .adv_w = 256, .box_w = 15, .box_h = 12, .ofs_x = 0, .ofs_y = 0},
{.bitmap_index = 5837, .adv_w = 256, .box_w = 14, .box_h = 12, .ofs_x = 1, .ofs_y = 0},
{.bitmap_index = 5878, .adv_w = 256, .box_w = 16, .box_h = 11, .ofs_x = 0, .ofs_y = 0},
{.bitmap_index = 5923, .adv_w = 256, .box_w = 14, .box_h = 14, .ofs_x = 1, .ofs_y = -1},
{.bitmap_index = 5980, .adv_w = 256, .box_w = 16, .box_h = 12, .ofs_x = 0, .ofs_y = 0},
{.bitmap_index = 6012, .adv_w = 256, .box_w = 14, .box_h = 13, .ofs_x = 1, .ofs_y = -1},
{.bitmap_index = 6072, .adv_w = 256, .box_w = 10, .box_h = 14, .ofs_x = 3, .ofs_y = -1},
{.bitmap_index = 6113, .adv_w = 256, .box_w = 12, .box_h = 15, .ofs_x = 2, .ofs_y = -1},
{.bitmap_index = 6163, .adv_w = 256, .box_w = 10, .box_h = 2, .ofs_x = 3, .ofs_y = 5},
{.bitmap_index = 6168, .adv_w = 256, .box_w = 8, .box_h = 10, .ofs_x = 4, .ofs_y = 1},
{.bitmap_index = 6181, .adv_w = 256, .box_w = 8, .box_h = 10, .ofs_x = 5, .ofs_y = 1},
{.bitmap_index = 6205, .adv_w = 256, .box_w = 10, .box_h = 10, .ofs_x = 3, .ofs_y = 1},
{.bitmap_index = 6227, .adv_w = 256, .box_w = 11, .box_h = 12, .ofs_x = 2, .ofs_y = 0},
{.bitmap_index = 6272, .adv_w = 256, .box_w = 14, .box_h = 14, .ofs_x = 1, .ofs_y = -1},
{.bitmap_index = 6340, .adv_w = 256, .box_w = 13, .box_h = 14, .ofs_x = 1, .ofs_y = -1},
{.bitmap_index = 6386, .adv_w = 256, .box_w = 13, .box_h = 14, .ofs_x = 1, .ofs_y = -1},
{.bitmap_index = 6443, .adv_w = 256, .box_w = 13, .box_h = 14, .ofs_x = 1, .ofs_y = -1},
{.bitmap_index = 6493, .adv_w = 256, .box_w = 14, .box_h = 14, .ofs_x = 1, .ofs_y = -1},
{.bitmap_index = 6560, .adv_w = 256, .box_w = 12, .box_h = 12, .ofs_x = 2, .ofs_y = 0},
{.bitmap_index = 6609, .adv_w = 256, .box_w = 10, .box_h = 10, .ofs_x = 3, .ofs_y = 1},
{.bitmap_index = 6636, .adv_w = 256, .box_w = 8, .box_h = 8, .ofs_x = 4, .ofs_y = 2},
{.bitmap_index = 6654, .adv_w = 256, .box_w = 8, .box_h = 8, .ofs_x = 4, .ofs_y = 2},
{.bitmap_index = 6672, .adv_w = 256, .box_w = 16, .box_h = 11, .ofs_x = 0, .ofs_y = 0},
{.bitmap_index = 6722, .adv_w = 256, .box_w = 10, .box_h = 14, .ofs_x = 3, .ofs_y = -1},
{.bitmap_index = 6767, .adv_w = 256, .box_w = 8, .box_h = 8, .ofs_x = 4, .ofs_y = 2},
{.bitmap_index = 6772, .adv_w = 256, .box_w = 14, .box_h = 14, .ofs_x = 1, .ofs_y = -1},
{.bitmap_index = 6836, .adv_w = 256, .box_w = 16, .box_h = 13, .ofs_x = 0, .ofs_y = -1},
{.bitmap_index = 6873, .adv_w = 256, .box_w = 8, .box_h = 14, .ofs_x = 4, .ofs_y = -1},
{.bitmap_index = 6905, .adv_w = 256, .box_w = 12, .box_h = 15, .ofs_x = 2, .ofs_y = -1},
{.bitmap_index = 6964, .adv_w = 256, .box_w = 12, .box_h = 16, .ofs_x = 2, .ofs_y = -2},
{.bitmap_index = 7024, .adv_w = 256, .box_w = 12, .box_h = 12, .ofs_x = 2, .ofs_y = 0},
{.bitmap_index = 7068, .adv_w = 256, .box_w = 10, .box_h = 12, .ofs_x = 3, .ofs_y = 0},
{.bitmap_index = 7099, .adv_w = 256, .box_w = 8, .box_h = 12, .ofs_x = 4, .ofs_y = 0},
{.bitmap_index = 7130, .adv_w = 256, .box_w = 8, .box_h = 12, .ofs_x = 4, .ofs_y = 0},
{.bitmap_index = 7167, .adv_w = 256, .box_w = 14, .box_h = 14, .ofs_x = 1, .ofs_y = -1},
{.bitmap_index = 7221, .adv_w = 256, .box_w = 16, .box_h = 10, .ofs_x = 0, .ofs_y = 1},
{.bitmap_index = 7269, .adv_w = 256, .box_w = 16, .box_h = 12, .ofs_x = 0, .ofs_y = 0},
{.bitmap_index = 7326, .adv_w = 256, .box_w = 16, .box_h = 14, .ofs_x = 0, .ofs_y = -1},
{.bitmap_index = 7396, .adv_w = 256, .box_w = 16, .box_h = 14, .ofs_x = 0, .ofs_y = -1},
{.bitmap_index = 7467, .adv_w = 256, .box_w = 14, .box_h = 15, .ofs_x = 1, .ofs_y = -1},
{.bitmap_index = 7538, .adv_w = 256, .box_w = 15, .box_h = 14, .ofs_x = 0, .ofs_y = -1},
{.bitmap_index = 7605, .adv_w = 256, .box_w = 16, .box_h = 14, .ofs_x = 0, .ofs_y = -1},
{.bitmap_index = 7677, .adv_w = 256, .box_w = 16, .box_h = 14, .ofs_x = 0, .ofs_y = -1},
{.bitmap_index = 7749, .adv_w = 256, .box_w = 16, .box_h = 15, .ofs_x = 0, .ofs_y = -2},
{.bitmap_index = 7823, .adv_w = 256, .box_w = 12, .box_h = 14, .ofs_x = 2, .ofs_y = -1},
{.bitmap_index = 7878, .adv_w = 256, .box_w = 14, .box_h = 14, .ofs_x = 1, .ofs_y = -1},
{.bitmap_index = 7930, .adv_w = 256, .box_w = 14, .box_h = 14, .ofs_x = 1, .ofs_y = -1},
{.bitmap_index = 7985, .adv_w = 256, .box_w = 16, .box_h = 15, .ofs_x = 0, .ofs_y = -1},
{.bitmap_index = 8053, .adv_w = 256, .box_w = 16, .box_h = 12, .ofs_x = 0, .ofs_y = 0},
{.bitmap_index = 8115, .adv_w = 256, .box_w = 12, .box_h = 12, .ofs_x = 2, .ofs_y = 0},
{.bitmap_index = 8160, .adv_w = 256, .box_w = 13, .box_h = 13, .ofs_x = 2, .ofs_y = -1},
{.bitmap_index = 8213, .adv_w = 256, .box_w = 14, .box_h = 13, .ofs_x = 1, .ofs_y = 0},
{.bitmap_index = 8269, .adv_w = 256, .box_w = 11, .box_h = 13, .ofs_x = 3, .ofs_y = -1},
{.bitmap_index = 8303, .adv_w = 256, .box_w = 14, .box_h = 12, .ofs_x = 1, .ofs_y = 0},
{.bitmap_index = 8354, .adv_w = 256, .box_w = 16, .box_h = 14, .ofs_x = 0, .ofs_y = -1},
{.bitmap_index = 8426, .adv_w = 256, .box_w = 16, .box_h = 14, .ofs_x = 0, .ofs_y = -1},
{.bitmap_index = 8501, .adv_w = 256, .box_w = 12, .box_h = 16, .ofs_x = 2, .ofs_y = -2},
{.bitmap_index = 8564, .adv_w = 256, .box_w = 14, .box_h = 12, .ofs_x = 1, .ofs_y = 0},
{.bitmap_index = 8611, .adv_w = 256, .box_w = 8, .box_h = 12, .ofs_x = 4, .ofs_y = 0},
{.bitmap_index = 8637, .adv_w = 256, .box_w = 12, .box_h = 14, .ofs_x = 2, .ofs_y = -1},
{.bitmap_index = 8682, .adv_w = 256, .box_w = 12, .box_h = 12, .ofs_x = 2, .ofs_y = 0},
{.bitmap_index = 8717, .adv_w = 256, .box_w = 12, .box_h = 12, .ofs_x = 2, .ofs_y = 0},
{.bitmap_index = 8752, .adv_w = 256, .box_w = 16, .box_h = 16, .ofs_x = 0, .ofs_y = -2},
{.bitmap_index = 8822, .adv_w = 256, .box_w = 14, .box_h = 14, .ofs_x = 1, .ofs_y = -1},
{.bitmap_index = 8891, .adv_w = 256, .box_w = 12, .box_h = 15, .ofs_x = 1, .ofs_y = -2},
{.bitmap_index = 8944, .adv_w = 256, .box_w = 13, .box_h = 14, .ofs_x = 1, .ofs_y = -1},
{.bitmap_index = 9006, .adv_w = 256, .box_w = 12, .box_h = 14, .ofs_x = 2, .ofs_y = -1},
{.bitmap_index = 9061, .adv_w = 256, .box_w = 13, .box_h = 12, .ofs_x = 1, .ofs_y = 0},
{.bitmap_index = 9106, .adv_w = 256, .box_w = 13, .box_h = 12, .ofs_x = 2, .ofs_y = 0},
{.bitmap_index = 9147, .adv_w = 256, .box_w = 12, .box_h = 12, .ofs_x = 2, .ofs_y = 0},
{.bitmap_index = 9182, .adv_w = 256, .box_w = 14, .box_h = 11, .ofs_x = 1, .ofs_y = 0},
{.bitmap_index = 9228, .adv_w = 256, .box_w = 14, .box_h = 12, .ofs_x = 1, .ofs_y = 0},
{.bitmap_index = 9261, .adv_w = 256, .box_w = 14, .box_h = 13, .ofs_x = 1, .ofs_y = 0},
{.bitmap_index = 9298, .adv_w = 256, .box_w = 8, .box_h = 14, .ofs_x = 4, .ofs_y = -1},
{.bitmap_index = 9324, .adv_w = 256, .box_w = 12, .box_h = 14, .ofs_x = 2, .ofs_y = -1},
{.bitmap_index = 9379, .adv_w = 256, .box_w = 11, .box_h = 13, .ofs_x = 2, .ofs_y = -1},
{.bitmap_index = 9419, .adv_w = 256, .box_w = 16, .box_h = 15, .ofs_x = 0, .ofs_y = -2},
{.bitmap_index = 9493, .adv_w = 256, .box_w = 10, .box_h = 14, .ofs_x = 3, .ofs_y = -1},
{.bitmap_index = 9538, .adv_w = 256, .box_w = 14, .box_h = 14, .ofs_x = 1, .ofs_y = -1},
{.bitmap_index = 9600, .adv_w = 256, .box_w = 12, .box_h = 16, .ofs_x = 2, .ofs_y = -2},
{.bitmap_index = 9660, .adv_w = 256, .box_w = 14, .box_h = 14, .ofs_x = 1, .ofs_y = -1},
{.bitmap_index = 9709, .adv_w = 256, .box_w = 12, .box_h = 14, .ofs_x = 2, .ofs_y = -1},
{.bitmap_index = 9754, .adv_w = 256, .box_w = 12, .box_h = 14, .ofs_x = 2, .ofs_y = -1},
{.bitmap_index = 9794, .adv_w = 256, .box_w = 12, .box_h = 12, .ofs_x = 2, .ofs_y = 0},
{.bitmap_index = 9825, .adv_w = 256, .box_w = 12, .box_h = 14, .ofs_x = 2, .ofs_y = -1},
{.bitmap_index = 9869, .adv_w = 256, .box_w = 14, .box_h = 7, .ofs_x = 1, .ofs_y = -1},
{.bitmap_index = 9900, .adv_w = 256, .box_w = 14, .box_h = 10, .ofs_x = 1, .ofs_y = 1},
{.bitmap_index = 9937, .adv_w = 256, .box_w = 16, .box_h = 14, .ofs_x = 0, .ofs_y = -1},
{.bitmap_index = 9997, .adv_w = 256, .box_w = 15, .box_h = 15, .ofs_x = 1, .ofs_y = -1},
{.bitmap_index = 10051, .adv_w = 256, .box_w = 14, .box_h = 10, .ofs_x = 1, .ofs_y = 3},
{.bitmap_index = 10088, .adv_w = 256, .box_w = 14, .box_h = 14, .ofs_x = 1, .ofs_y = -1},
{.bitmap_index = 10151, .adv_w = 256, .box_w = 12, .box_h = 14, .ofs_x = 2, .ofs_y = -1},
{.bitmap_index = 10197, .adv_w = 256, .box_w = 15, .box_h = 13, .ofs_x = 0, .ofs_y = 0},
{.bitmap_index = 10243, .adv_w = 256, .box_w = 12, .box_h = 12, .ofs_x = 2, .ofs_y = 0},
{.bitmap_index = 10285, .adv_w = 256, .box_w = 14, .box_h = 12, .ofs_x = 1, .ofs_y = 0},
{.bitmap_index = 10330, .adv_w = 256, .box_w = 12, .box_h = 12, .ofs_x = 2, .ofs_y = 0},
{.bitmap_index = 10360, .adv_w = 256, .box_w = 16, .box_h = 15, .ofs_x = 0, .ofs_y = -2},
{.bitmap_index = 10408, .adv_w = 256, .box_w = 14, .box_h = 12, .ofs_x = 1, .ofs_y = 0},
{.bitmap_index = 10467, .adv_w = 256, .box_w = 16, .box_h = 10, .ofs_x = 0, .ofs_y = 1},
{.bitmap_index = 10522, .adv_w = 256, .box_w = 8, .box_h = 14, .ofs_x = 4, .ofs_y = -1},
{.bitmap_index = 10547, .adv_w = 256, .box_w = 8, .box_h = 14, .ofs_x = 4, .ofs_y = -1},
{.bitmap_index = 10576, .adv_w = 256, .box_w = 8, .box_h = 14, .ofs_x = 4, .ofs_y = -1},
{.bitmap_index = 10612, .adv_w = 256, .box_w = 16, .box_h = 10, .ofs_x = 0, .ofs_y = 1},
{.bitmap_index = 10671, .adv_w = 256, .box_w = 14, .box_h = 11, .ofs_x = 1, .ofs_y = 0},
{.bitmap_index = 10713, .adv_w = 256, .box_w = 14, .box_h = 11, .ofs_x = 1, .ofs_y = 0},
{.bitmap_index = 10750, .adv_w = 256, .box_w = 14, .box_h = 16, .ofs_x = 1, .ofs_y = -2},
{.bitmap_index = 10818, .adv_w = 256, .box_w = 8, .box_h = 16, .ofs_x = 4, .ofs_y = -2}
};
/*---------------------
* CHARACTER MAPPING
*--------------------*/
static const uint16_t unicode_list_1[] = {
0x0, 0x1, 0x3, 0x10, 0x11, 0x12, 0x13, 0x15
};
static const uint16_t unicode_list_3[] = {
0x0, 0x1, 0x12, 0x13, 0x34, 0x35, 0x40, 0x41,
0x42, 0x43, 0x5f, 0x60, 0x1d80, 0x1f04, 0x1f8e
};
static const uint16_t unicode_list_4[] = {
0x0, 0x17, 0x22, 0x41, 0x49, 0x50, 0x59, 0x8a,
0x96, 0xa8, 0xab, 0xe9, 0x107, 0x118, 0x128, 0x13c,
0x13d, 0x13e, 0x13f, 0x14c, 0x152, 0x172, 0x1d5, 0x1f6,
0x20c, 0x234, 0x28b, 0x2d6, 0x2d8, 0x2df, 0x307, 0x31e,
0x326, 0x331, 0x33a, 0x370, 0x3e0, 0x406, 0x411, 0x421,
0x434, 0x452, 0x453, 0x454, 0x48f, 0x499, 0x49a, 0x4a9,
0x4aa, 0x4b5, 0x4bf, 0x4d7, 0x4da, 0x4fe, 0x50b, 0x517,
0x561, 0x57a, 0x57c, 0x588, 0x58a, 0x58b, 0x58c, 0x58d,
0x58e, 0x58f, 0x590, 0x591, 0x592, 0x593, 0x594, 0x595,
0x599, 0x59a, 0x5a4, 0x5a5, 0x5ed, 0x5f6, 0x602, 0x608,
0x646, 0x67a, 0x67b, 0x686, 0x69d, 0x6a1, 0x6b1, 0x6bc,
0x6bf, 0x6e4, 0x709, 0x70a, 0x713, 0x726, 0x756, 0x75b,
0x765, 0x7aa, 0x817, 0x818, 0x8d9, 0x913, 0x918, 0x953,
0x95b, 0x967, 0x999, 0x99c, 0x9a7, 0xa6c, 0xa76, 0xaa8,
0xad3, 0xc95, 0xf5b, 0xfc2, 0x100d, 0x101c, 0x1050, 0x10ab,
0x1118, 0x1119, 0x111a, 0x11d7, 0x11dd, 0x11ef, 0x129d, 0x129e,
0x129f, 0x12b6, 0x12cf, 0x12d0, 0x1399, 0x1407
};
/*Collect the unicode lists and glyph_id offsets*/
static const lv_font_fmt_txt_cmap_t cmaps[] =
{
{
.range_start = 32, .range_length = 95, .glyph_id_start = 1,
.unicode_list = NULL, .glyph_id_ofs_list = NULL, .list_length = 0, .type = LV_FONT_FMT_TXT_CMAP_FORMAT0_TINY
},
{
.range_start = 160, .range_length = 22, .glyph_id_start = 96,
.unicode_list = unicode_list_1, .glyph_id_ofs_list = NULL, .list_length = 8, .type = LV_FONT_FMT_TXT_CMAP_SPARSE_TINY
},
{
.range_start = 191, .range_length = 65, .glyph_id_start = 104,
.unicode_list = NULL, .glyph_id_ofs_list = NULL, .list_length = 0, .type = LV_FONT_FMT_TXT_CMAP_FORMAT0_TINY
},
{
.range_start = 286, .range_length = 8079, .glyph_id_start = 169,
.unicode_list = unicode_list_3, .glyph_id_ofs_list = NULL, .list_length = 15, .type = LV_FONT_FMT_TXT_CMAP_SPARSE_TINY
},
{
.range_start = 983044, .range_length = 5128, .glyph_id_start = 184,
.unicode_list = unicode_list_4, .glyph_id_ofs_list = NULL, .list_length = 134, .type = LV_FONT_FMT_TXT_CMAP_SPARSE_TINY
}
};
/*--------------------
* ALL CUSTOM DATA
*--------------------*/
#if LV_VERSION_CHECK(8, 0, 0)
/*Store all the custom data of the font*/
static lv_font_fmt_txt_glyph_cache_t cache;
static const lv_font_fmt_txt_dsc_t font_dsc = {
#else
static lv_font_fmt_txt_dsc_t font_dsc = {
#endif
.glyph_bitmap = glyph_bitmap,
.glyph_dsc = glyph_dsc,
.cmaps = cmaps,
.kern_dsc = NULL,
.kern_scale = 0,
.cmap_num = 5,
.bpp = 3,
.kern_classes = 0,
.bitmap_format = 1,
#if LV_VERSION_CHECK(8, 0, 0)
.cache = &cache
#endif
};
/*-----------------
* PUBLIC FONT
*----------------*/
/*Initialize a public general font descriptor*/
#if LV_VERSION_CHECK(8, 0, 0)
const lv_font_t robotocondensed_regular_16_latin1 = {
#else
lv_font_t robotocondensed_regular_16_latin1 = {
#endif
.get_glyph_dsc = lv_font_get_glyph_dsc_fmt_txt, /*Function pointer to get glyph's data*/
.get_glyph_bitmap = lv_font_get_bitmap_fmt_txt, /*Function pointer to get glyph's bitmap*/
.line_height = 20, /*The maximum line height required by the font*/
.base_line = 4, /*Baseline measured from the bottom of the line*/
#if !(LVGL_VERSION_MAJOR == 6 && LVGL_VERSION_MINOR == 0)
.subpx = LV_FONT_SUBPX_NONE,
#endif
#if LV_VERSION_CHECK(7, 4, 0)
.underline_position = -1,
.underline_thickness = 1,
#endif
.dsc = &font_dsc /*The custom font data. Will be accessed by `get_glyph_bitmap/dsc` */
};
#endif /*#if ROBOTOCONDENSED_REGULAR_16_LATIN1*/
| [
"[email protected]"
] | |
7556fee3c96cb65de3b4f321d2939635fc6bc8ef | 1a17167c38dc9a12c1f72dd0f3ae7288f5cd7da0 | /Source/ThirdParty/angle/third_party/SwiftShader/src/D3D8/Direct3DStateBlock8.hpp | 6d602aafaccbfff22c5a537261a2cb143eac34c4 | [
"BSD-3-Clause",
"LicenseRef-scancode-unknown-license-reference",
"MIT",
"LicenseRef-scancode-warranty-disclaimer",
"Zlib",
"LicenseRef-scancode-khronos",
"BSL-1.0",
"BSD-2-Clause",
"Apache-2.0"
] | permissive | elix22/Urho3D | c57c7ecb58975f51fabb95bcc4330bc5b0812de7 | 99902ae2a867be0d6dbe4c575f9c8c318805ec64 | refs/heads/master | 2023-06-01T01:19:57.155566 | 2021-12-07T16:47:20 | 2021-12-07T17:46:58 | 165,504,739 | 21 | 4 | MIT | 2021-11-05T01:02:08 | 2019-01-13T12:51:17 | C++ | UTF-8 | C++ | false | false | 4,881 | hpp | // Copyright 2016 The SwiftShader Authors. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#ifndef D3D8_Direct3DStateBlock8_hpp
#define D3D8_Direct3DStateBlock8_hpp
#include "Unknown.hpp"
#include <vector>
#include <d3d8.h>
namespace D3D8
{
class Direct3DDevice8;
class Direct3DBaseTexture8;
class Direct3DVertexBuffer8;
class Direct3DIndexBuffer8;
class Direct3DStateBlock8 : public Unknown
{
public:
Direct3DStateBlock8(Direct3DDevice8 *device, D3DSTATEBLOCKTYPE type);
~Direct3DStateBlock8() override;
// IUnknown methods
long __stdcall QueryInterface(const IID &iid, void **object) override;
unsigned long __stdcall AddRef() override;
unsigned long __stdcall Release() override;
long __stdcall Apply();
long __stdcall Capture();
long __stdcall GetDevice(IDirect3DDevice8 **device);
// Internal methods
void lightEnable(unsigned long index, int enable);
void setClipPlane(unsigned long index, const float *plane);
void setCurrentTexturePalette(unsigned int paletteNumber);
void setFVF(unsigned long FVF);
void setIndices(Direct3DIndexBuffer8 *indexData, unsigned int baseVertexIndex);
void setLight(unsigned long index, const D3DLIGHT8 *light);
void setMaterial(const D3DMATERIAL8 *material);
void setPixelShader(unsigned long shaderHandle);
void setPixelShaderConstant(unsigned int startRegister, const void *constantData, unsigned int count);
void setRenderState(D3DRENDERSTATETYPE state, unsigned long value);
void setScissorRect(const RECT *rect);
void setStreamSource(unsigned int stream, Direct3DVertexBuffer8 *data, unsigned int stride);
void setTexture(unsigned long stage, Direct3DBaseTexture8 *texture);
void setTextureStageState(unsigned long stage, D3DTEXTURESTAGESTATETYPE type, unsigned long value);
void setTransform(D3DTRANSFORMSTATETYPE state, const D3DMATRIX *matrix);
void setViewport(const D3DVIEWPORT8 *viewport);
void setVertexShader(unsigned long shaderHandle);
void setVertexShaderConstant(unsigned int startRegister, const void *constantData, unsigned int count);
private:
// Individual states
void captureRenderState(D3DRENDERSTATETYPE state);
void captureTextureStageState(unsigned long stage, D3DTEXTURESTAGESTATETYPE type);
void captureTransform(D3DTRANSFORMSTATETYPE state);
// Pixel states
void capturePixelRenderStates();
void capturePixelTextureStates();
void capturePixelShaderStates();
// Vertex states
void captureVertexRenderStates();
void captureVertexTextureStates();
void captureLightStates();
void captureVertexShaderStates();
// All (remaining) states
void captureTextures();
void captureVertexTextures();
void captureDisplacementTextures();
void captureTexturePalette();
void captureVertexStreams();
void captureIndexBuffer();
void captureViewport();
void captureTransforms();
void captureTextureTransforms();
void captureClippingPlanes();
void captureMaterial();
// Creation parameters
Direct3DDevice8 *const device;
const D3DSTATEBLOCKTYPE type;
// State data
bool vertexShaderCaptured;
unsigned long vertexShaderHandle;
bool pixelShaderCaptured;
unsigned long pixelShaderHandle;
bool indexBufferCaptured;
Direct3DIndexBuffer8 *indexBuffer;
unsigned int baseVertexIndex;
bool renderStateCaptured[D3DRS_NORMALORDER + 1];
unsigned long renderState[D3DRS_NORMALORDER + 1];
bool textureStageStateCaptured[8][D3DTSS_RESULTARG + 1];
unsigned long textureStageState[8][D3DTSS_RESULTARG + 1];
bool streamSourceCaptured[16];
struct StreamSource
{
Direct3DVertexBuffer8 *vertexBuffer;
unsigned int stride;
};
StreamSource streamSource[16];
bool textureCaptured[8];
Direct3DBaseTexture8 *texture[8];
bool transformCaptured[512];
D3DMATRIX transform[512];
bool viewportCaptured;
D3DVIEWPORT8 viewport;
bool clipPlaneCaptured[6];
float clipPlane[6][4];
bool materialCaptured;
D3DMATERIAL8 material;
bool lightCaptured[8]; // FIXME: Unlimited index
D3DLIGHT8 light[8];
bool lightEnableCaptured[8]; // FIXME: Unlimited index
int lightEnableState[8];
float pixelShaderConstant[8][4];
float vertexShaderConstant[256][4];
bool scissorRectCaptured;
RECT scissorRect;
bool paletteNumberCaptured;
unsigned int paletteNumber;
void clear();
};
}
#endif // D3D8_Direct3DStateBlock8_hpp | [
"[email protected]"
] | |
9be8968cf3c621e400aa4349c570dac96ea7b662 | a4c8c67ac6a91e76402ae6f7f053668b52629ed8 | /src/game-server/commands/CommandList.hpp | 917faecd6678f60b7fddca4fccf721ca4ea6cdb4 | [] | no_license | joshfernandez/cmpt373_combatgame | 229cb9ba8bc06b90631faca4e6aa198f55a0733e | bc3094d20ab963b50c184ad2a036a0908cc82d97 | refs/heads/master | 2021-01-12T02:33:02.982661 | 2017-01-04T23:15:24 | 2017-01-04T23:15:24 | 78,059,742 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 782 | hpp | #ifndef ADVENTURE2016_COMMANDLIST_HPP
#define ADVENTURE2016_COMMANDLIST_HPP
#include <string>
static const std::string COMMAND_HELP = "help";
static const std::string COMMAND_EXITS = "exits";
static const std::string COMMAND_PLAYERS = "players";
static const std::string COMMAND_LOOK = "look";
static const std::string COMMAND_MOVE = "move";
static const std::string COMMAND_SAY = "say";
static const std::string COMMAND_WHISPER = "whisper";
static const std::string COMMAND_SHOUT = "shout";
static const std::string COMMAND_ATTACK = "attack";
static const std::string COMMAND_CAST = "cast";
static const std::string COMMAND_STATUS = "status";
static const std::string COMMAND_KICK = "kick";
static const std::string COMMAND_EDIT = "edit";
#endif //ADVENTURE2016_COMMANDLIST_HPP
| [
"[email protected]"
] | |
326652108e459dc8f1f70f15b9e21530123a23f9 | 8fd50e99f4ed3df64703a167e113dd934e494e31 | /include/izvestaj.hpp | 58878ae8b3c359a0e7bc1ca09880657d7c5e9080 | [] | no_license | Obadovv/Douglas | 3b36c4a3efb1daa37d3edb4a3d3754c7bc47ba80 | ae7c9df5f036c83ce7116af445e5bf7953e279cd | refs/heads/master | 2022-09-04T09:42:13.118358 | 2020-05-25T22:00:20 | 2020-05-25T22:00:20 | 260,047,215 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,276 | hpp | #ifndef IZVESTAJ_HPP
#define IZVESTAJ_HPP
#include <fstream>
#include "kasadouglas.hpp"
using namespace std;
class Izvestaj
{
public:
Izvestaj();
void zapocniDan(KasaDouglas);
void zavrsiDan(KasaDouglas);
void promenaUTokuDana(string);
int getPocetnaKolicinaRobe () const { return pocetnaKolicinaRobe;}
int getPocetnaVrednostRobe () const { return pocetnaVrednostRobe;}
void setPocetnaKolicinaRobe (int val){ pocetnaKolicinaRobe = val; }
void setPocetnaVrednostRobe (int val){ pocetnaVrednostRobe = val; }
void uvecajPocetnuKolicinuRobe (int val){ pocetnaKolicinaRobe += val; }
void uvecajPocetnuVrednostRobe (int val){ pocetnaVrednostRobe += val; }
int getKrajnjaKolicinaRobe () const { return krajnjaKolicinaRobe;}
int getKrajnjaVrednostRobe () const { return krajnjaVrednostRobe;}
void setKrajnjaKolicinaRobe (int val){ krajnjaKolicinaRobe = val; }
void setKrajnjaVrednostRobe (int val){ krajnjaVrednostRobe = val; }
private:
int pocetnaKolicinaRobe;
int pocetnaVrednostRobe;
int krajnjaKolicinaRobe;
int krajnjaVrednostRobe;
ofstream celodnevniIzvestaj;
};
#endif // IZVESTAJ_HPP
| [
"[email protected]"
] | |
a2ef8da34a88f71dad5f4336444f4da973845d1b | c9cf0586ace11aa32fa67606d237a130a06364ee | /circular-cylinder-10-10/19.7575/U | 456886ce988370c4dafa695e967f1f47e4f814f4 | [] | no_license | jezvonek/CFD-Final-Project | c74cfa21f22545c27d97d85cf30eb6dc8c824dc1 | 7c9a7fb032d74f20888effa0a0b75b212bf899f4 | refs/heads/master | 2022-07-05T14:43:52.967657 | 2020-05-14T03:40:56 | 2020-05-14T03:40:56 | 262,370,756 | 1 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 76,742 | /*--------------------------------*- C++ -*----------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Version: 6.0
\\/ M anipulation |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class volVectorField;
location "19.7575";
object U;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
dimensions [0 1 -1 0 0 0 0];
internalField nonuniform List<vector>
2400
(
(0.435868 -4.19936 -1.69747e-19)
(0.162901 -3.44959 6.50786e-20)
(0.237329 -3.02563 -5.07783e-20)
(0.352547 -2.76781 -2.99233e-20)
(0.450354 -2.59577 -3.76133e-20)
(0.540257 -2.46545 5.46192e-20)
(0.621858 -2.35497 1.6912e-20)
(0.692797 -2.25383 1.25064e-20)
(0.753581 -2.1563 -2.77405e-20)
(0.80438 -2.05733 -2.50228e-21)
(0.769658 -4.17603 2.07831e-19)
(0.449915 -3.49763 -5.09857e-21)
(0.500531 -3.10376 4.30555e-20)
(0.601453 -2.8591 2.86024e-19)
(0.688126 -2.69107 -1.99032e-19)
(0.767167 -2.558 -5.21768e-21)
(0.837298 -2.44067 -4.22124e-21)
(0.896148 -2.33083 -2.34024e-20)
(0.944676 -2.22428 -2.56818e-20)
(0.983146 -2.117 -1.16117e-21)
(1.10355 -4.12988 4.02311e-19)
(0.745859 -3.5273 2.9335e-19)
(0.776506 -3.16397 -7.27661e-19)
(0.864113 -2.93134 2.08735e-19)
(0.938935 -2.76588 2.75136e-19)
(1.0054 -2.62889 -1.53148e-19)
(1.06192 -2.50406 -1.23421e-19)
(1.10654 -2.3855 8.22992e-20)
(1.14092 -2.27049 -1.67994e-19)
(1.16537 -2.15629 1.68305e-19)
(1.43588 -4.06026 -1.38475e-18)
(1.0496 -3.53658 4.97425e-19)
(1.0638 -3.20347 -4.86788e-19)
(1.13855 -2.98151 2.00605e-19)
(1.20035 -2.81727 -1.92771e-19)
(1.25223 -2.67556 2.642e-19)
(1.29287 -2.5431 8.36707e-20)
(1.32117 -2.4163 -3.76845e-19)
(1.33972 -2.29391 -2.92878e-19)
(1.3488 -2.17466 3.14495e-19)
(1.76516 -3.96666 6.52726e-20)
(1.35974 -3.52342 -2.07291e-19)
(1.36054 -3.21956 -1.04449e-19)
(1.42236 -3.00676 -1.02159e-19)
(1.46956 -2.84267 -5.2846e-19)
(1.50466 -2.6959 6.36105e-20)
(1.52717 -2.5562 -4.91027e-20)
(1.53721 -2.42217 4.08925e-19)
(1.53845 -2.2939 -2.7865e-19)
(1.53114 -2.17177 -1.52899e-19)
(2.08967 -3.84861 1.34175e-18)
(1.67443 -3.48588 -1.1728e-19)
(1.66438 -3.20974 1.42077e-18)
(1.71272 -3.0047 -1.96563e-19)
(1.74349 -2.84005 6.7361e-19)
(1.75957 -2.68839 -9.11086e-20)
(1.76184 -2.54238 1.24519e-20)
(1.75189 -2.40255 3.68466e-19)
(1.7346 -2.27015 -2.01684e-19)
(1.71019 -2.14739 2.67126e-19)
(2.4076 -3.70577 -5.34978e-19)
(1.99145 -3.42218 1.00404e-19)
(1.97254 -3.17189 -3.72935e-19)
(2.00646 -2.97333 -3.64067e-19)
(2.01885 -2.80789 1.53555e-20)
(2.01379 -2.6521 1.08337e-18)
(1.994 -2.50126 -3.71835e-19)
(1.96274 -2.35748 1.1361e-19)
(1.92611 -2.22285 -5.17069e-19)
(1.88445 -2.10151 -2.33411e-19)
(2.71714 -3.53808 2.35059e-18)
(2.30836 -3.33088 -3.35835e-19)
(2.28193 -3.10424 -2.10297e-18)
(2.30014 -2.91117 1.06823e-19)
(2.29212 -2.74517 3.88981e-19)
(2.26399 -2.58652 -5.20888e-19)
(2.22067 -2.43282 -6.33798e-19)
(2.16726 -2.28725 9.07516e-19)
(2.11109 -2.15241 -8.01455e-20)
(2.05266 -2.03511 -6.64193e-19)
(3.01661 -3.3457 -1.97506e-18)
(2.6226 -3.21082 1.00663e-18)
(2.58933 -3.00547 1.39452e-18)
(2.59025 -2.81723 3.20105e-19)
(2.55982 -2.65132 -1.13485e-18)
(2.50677 -2.49143 6.88662e-19)
(2.43853 -2.33694 3.64526e-19)
(2.36211 -2.19161 7.36735e-19)
(2.28573 -2.05883 -4.71331e-19)
(2.20999 -1.95041 -5.8425e-19)
(3.30401 -3.12848 6.5581e-19)
(2.93134 -3.06095 -2.453e-19)
(2.8914 -2.87484 -5.74728e-20)
(2.87346 -2.69128 3.24824e-19)
(2.81895 -2.52652 2.49702e-19)
(2.73966 -2.36708 -1.87119e-19)
(2.64541 -2.21351 -3.09531e-19)
(2.5445 -2.06991 4.9053e-19)
(2.44431 -1.94172 -3.91189e-19)
(2.34562 -1.84621 3.50627e-19)
(4.974 0.140275 4.27792e-20)
(4.93246 -0.248871 1.33048e-19)
(4.85856 -0.630132 -4.20854e-19)
(4.75392 -1.00095 3.82151e-19)
(4.61996 -1.3589 1.52009e-19)
(4.45836 -1.70173 1.90946e-18)
(4.27103 -2.02742 -7.54276e-19)
(4.06009 -2.33424 -1.04491e-18)
(3.82748 -2.62076 1.15856e-18)
(3.57593 -2.88554 -2.00917e-18)
(4.97514 -0.134938 1.2533e-19)
(4.90002 -0.514 -5.82077e-20)
(4.78934 -0.881368 -3.64457e-19)
(4.64526 -1.23364 9.79382e-19)
(4.47012 -1.56771 -3.36677e-19)
(4.26662 -1.88075 2.59129e-18)
(4.03773 -2.17034 -1.69127e-18)
(3.78667 -2.43451 2.40479e-18)
(3.51652 -2.67172 -1.69368e-18)
(3.2308 -2.88078 -8.54538e-19)
(4.83873 -0.104007 -2.3696e-19)
(4.77762 -0.463661 1.58669e-20)
(4.68051 -0.813787 -1.0241e-18)
(4.54902 -1.15053 7.78732e-19)
(4.38529 -1.47029 -8.43591e-19)
(4.19189 -1.76977 -1.64326e-18)
(3.97175 -2.04604 -5.63615e-19)
(3.72816 -2.29658 -3.95931e-19)
(3.4645 -2.51928 1.60985e-18)
(3.18454 -2.71244 9.20324e-19)
(4.59814 -0.0590548 9.71709e-20)
(4.55721 -0.392724 -1.68733e-19)
(4.48207 -0.719903 -2.32482e-19)
(4.37373 -1.03675 -9.52273e-19)
(4.23379 -1.3396 6.24264e-19)
(4.06431 -1.62504 1.70887e-18)
(3.86778 -1.88988 6.9554e-19)
(3.64711 -2.1313 1.47777e-19)
(3.40551 -2.34673 3.95635e-19)
(3.14649 -2.534 4.79956e-20)
(4.31693 -0.0459997 -1.02955e-19)
(4.29122 -0.351766 -4.05363e-19)
(4.23419 -0.653451 3.71957e-20)
(4.14643 -0.947519 7.60182e-19)
(4.02903 -1.23053 8.19956e-19)
(3.88354 -1.49923 -5.54727e-19)
(3.71199 -1.75049 -9.8539e-19)
(3.51676 -1.98149 -5.07546e-19)
(3.30076 -2.18943 5.52901e-19)
(3.06701 -2.3719 8.56615e-19)
(4.03604 -0.042576 2.51961e-20)
(4.02029 -0.321551 3.32724e-19)
(3.97639 -0.598094 -7.80689e-19)
(3.90466 -0.869083 9.55658e-19)
(3.80586 -1.13143 5.77675e-19)
(3.68115 -1.38223 1.09345e-18)
(3.53215 -1.61856 -2.32971e-19)
(3.36077 -1.83793 -6.50063e-19)
(3.16973 -2.0374 1.51827e-18)
(2.96145 -2.21482 -1.30175e-18)
(3.77633 -0.0416848 4.91465e-20)
(3.76615 -0.296339 -3.62335e-19)
(3.73083 -0.549559 -2.33363e-19)
(3.67053 -0.798636 -5.09704e-19)
(3.58584 -1.04086 -7.20879e-20)
(3.47762 -1.27377 -7.27189e-19)
(3.34723 -1.4947 -4.7237e-19)
(3.19616 -1.7018 -7.82385e-20)
(3.02721 -1.89191 -9.03093e-19)
(2.84194 -2.06387 1.24159e-18)
(3.54545 -0.0418518 -4.06903e-20)
(3.53773 -0.275205 2.99827e-19)
(3.50746 -0.507605 -1.3269e-19)
(3.4548 -0.736705 2.90704e-19)
(3.38023 -0.960144 6.99556e-19)
(3.28443 -1.17595 1.16706e-18)
(3.16861 -1.38169 -3.12799e-19)
(3.03381 -1.57657 -1.11259e-18)
(2.88332 -1.75678 3.285e-19)
(2.71719 -1.92342 -1.90167e-18)
(3.34343 -0.0411362 5.79221e-20)
(3.33634 -0.25653 -6.88549e-20)
(3.30886 -0.471175 -6.6818e-19)
(3.26115 -0.683006 2.01504e-19)
(3.1937 -0.889956 -4.80888e-19)
(3.10695 -1.09046 -2.06999e-19)
(3.00212 -1.28235 -1.33635e-19)
(2.87958 -1.46615 5.08549e-19)
(2.74349 -1.63724 4.93111e-19)
(2.59143 -1.80089 3.85038e-19)
(3.16657 -0.0409641 -1.33857e-19)
(3.15914 -0.240706 2.3311e-19)
(3.13317 -0.440287 1.13368e-19)
(3.08872 -0.63787 3.18169e-19)
(3.02623 -0.831605 -3.33137e-20)
(2.94575 -1.02019 -2.78517e-20)
(2.84859 -1.20152 -7.66064e-19)
(2.73371 -1.37732 1.00571e-18)
(2.60735 -1.54166 -6.29429e-19)
(2.46379 -1.70975 1.76345e-19)
(3.52748 3.7143 -1.24054e-18)
(3.81103 3.42968 1.2957e-18)
(4.0679 3.1214 -6.9408e-20)
(4.29629 2.79202 -2.21486e-18)
(4.49411 2.44404 1.6057e-18)
(4.65965 2.08035 -1.11697e-18)
(4.79165 1.70414 -2.51382e-19)
(4.88936 1.31879 -2.36881e-19)
(4.95234 0.927585 3.77603e-19)
(4.98086 0.534277 2.6913e-20)
(3.7002 3.38302 1.49562e-18)
(3.97542 3.11011 2.83262e-19)
(4.22353 2.81111 -1.50928e-18)
(4.4419 2.48867 -1.58141e-18)
(4.62796 2.1457 1.31165e-18)
(4.77947 1.78558 -1.04378e-18)
(4.89466 1.41206 1.16371e-18)
(4.97233 1.02918 -3.2775e-19)
(5.01169 0.640955 -9.72214e-19)
(5.01277 0.25172 -6.69628e-20)
(3.50828 3.11062 -2.68216e-19)
(3.77643 2.87454 -2.01416e-19)
(4.02129 2.61173 8.69693e-19)
(4.23972 2.3244 7.94074e-19)
(4.42888 2.01517 1.72051e-18)
(4.58629 1.68716 5.47536e-19)
(4.7098 1.34384 -3.87185e-19)
(4.79776 0.989028 -8.26612e-19)
(4.84894 0.626649 6.61542e-19)
(4.86272 0.26095 4.74758e-20)
(3.24729 2.8098 3.57078e-19)
(3.50023 2.60891 -8.40706e-19)
(3.73381 2.38239 -3.33167e-19)
(3.94488 2.13195 -1.46852e-18)
(4.13065 1.85977 -7.85823e-19)
(4.28862 1.56851 1.4494e-18)
(4.41661 1.26117 9.36617e-19)
(4.51279 0.941085 -7.88516e-19)
(4.5757 0.611799 3.38935e-20)
(4.60434 0.277129 -3.3597e-20)
(3.01161 2.50934 -1.2753e-18)
(3.24446 2.33609 1.45162e-18)
(3.46095 2.13921 -3.66318e-19)
(3.65813 1.91986 7.66422e-19)
(3.83344 1.67987 -5.07683e-19)
(3.98462 1.42153 -8.60493e-19)
(4.1096 1.14741 4.04456e-19)
(4.2066 0.860388 -4.35087e-19)
(4.27418 0.563574 -4.19766e-19)
(4.31118 0.26029 1.77549e-19)
(2.81082 2.24567 -1.71695e-19)
(3.02346 2.09368 2.70017e-19)
(3.2216 1.92023 -3.13384e-19)
(3.40274 1.72594 -1.4844e-18)
(3.5647 1.51243 8.02543e-19)
(3.70548 1.28173 1.30174e-19)
(3.82325 1.03608 -7.22903e-19)
(3.9164 0.778013 -2.46403e-19)
(3.98359 0.510264 2.25583e-19)
(4.0237 0.235719 -6.55931e-20)
(2.6453 2.02506 -6.60659e-19)
(2.83999 1.88938 4.02461e-21)
(3.02082 1.73431 3.19273e-19)
(3.18596 1.55991 8.39754e-19)
(3.33388 1.36773 1.74247e-19)
(3.46293 1.15961 4.21559e-19)
(3.57151 0.937587 8.25171e-19)
(3.65821 0.703941 -3.4815e-19)
(3.72187 0.461129 2.96787e-19)
(3.76145 0.211696 -1.11502e-19)
(2.50957 1.84331 -2.37492e-19)
(2.6888 1.72133 2.74933e-19)
(2.85451 1.58069 2.67689e-19)
(3.00494 1.42193 -3.99177e-19)
(3.13947 1.24675 -2.21677e-19)
(3.25691 1.05674 -4.77656e-19)
(3.3559 0.85384 4.59567e-20)
(3.4352 0.640253 -1.06159e-19)
(3.49377 0.418238 -6.31621e-19)
(3.5307 0.190079 8.49402e-20)
(2.39897 1.69472 -8.62419e-20)
(2.56146 1.5867 -4.51555e-19)
(2.71368 1.4571 -1.79556e-19)
(2.85151 1.3104 8.72915e-20)
(2.97416 1.14875 -5.02753e-20)
(3.08106 0.973239 4.23336e-19)
(3.17117 0.785725 1.69202e-19)
(3.24334 0.588413 2.53272e-19)
(3.29659 0.383439 2.97488e-19)
(3.33011 0.172883 -1.22058e-19)
(2.32807 1.55997 -3.09434e-19)
(2.46703 1.46314 5.47141e-19)
(2.60136 1.34225 -9.01749e-19)
(2.72642 1.20612 -1.55254e-20)
(2.83714 1.05713 7.47979e-19)
(2.93293 0.89549 3.62553e-20)
(3.01363 0.722658 3.31033e-19)
(3.07829 0.540686 -6.87545e-19)
(3.12582 0.35154 -6.1613e-21)
(3.15539 0.15705 6.14554e-20)
(0.675685 1.73219 7.30721e-21)
(0.636664 1.86848 -1.94324e-21)
(0.595305 2.03606 -2.72783e-21)
(0.548299 2.24786 2.36507e-20)
(0.496196 2.51968 -1.03901e-20)
(0.438724 2.86785 -4.53464e-20)
(0.378973 3.30391 6.14426e-20)
(0.334829 3.8228 2.46668e-20)
(0.259614 4.37919 4.22186e-20)
(-0.111642 4.86713 1.7833e-19)
(0.821644 1.78276 1.93216e-20)
(0.794739 1.92358 -6.47746e-20)
(0.766761 2.09535 6.86526e-20)
(0.736685 2.31086 1.67722e-20)
(0.706008 2.58548 -3.82201e-20)
(0.675436 2.93496 3.89748e-20)
(0.648834 3.36937 1.65555e-19)
(0.643511 3.87972 -2.18075e-19)
(0.60899 4.41925 1.20338e-20)
(0.272155 4.89483 -2.20866e-19)
(0.976078 1.81996 1.09726e-19)
(0.961758 1.96451 -1.44575e-19)
(0.947657 2.13962 -5.82056e-20)
(0.935046 2.35773 -5.99786e-21)
(0.926247 2.63373 -7.36827e-20)
(0.922821 2.98259 -3.35972e-20)
(0.929175 3.4128 5.85285e-20)
(0.961475 3.91138 1.71709e-19)
(0.964959 4.43062 1.34532e-19)
(0.658914 4.89147 -4.2174e-19)
(1.13786 1.8427 1.24194e-19)
(1.13636 1.99009 -1.38422e-19)
(1.13651 2.16758 -1.42334e-19)
(1.1418 2.38703 7.64145e-20)
(1.15521 2.66281 4.587e-19)
(1.17902 3.00904 -1.92534e-19)
(1.21794 3.43242 1.57825e-19)
(1.28646 3.91612 -5.67682e-19)
(1.3251 4.41201 -6.64317e-19)
(1.04618 4.8565 7.94045e-19)
(1.30571 1.85013 1.03409e-19)
(1.31699 1.99944 -6.7365e-20)
(1.33161 2.17822 2.02744e-19)
(1.35513 2.39758 -1.79282e-19)
(1.39095 2.6714 1.5132e-19)
(1.44192 3.01283 1.29856e-19)
(1.5128 3.42672 1.25639e-19)
(1.6159 3.89248 1.13138e-19)
(1.68666 4.36222 4.48326e-19)
(1.43124 4.78927 3.92099e-19)
(1.47811 1.8416 -3.60825e-19)
(1.50185 1.99187 -8.7912e-20)
(1.531 2.1707 4.01545e-19)
(1.57293 2.38839 -4.49482e-19)
(1.63123 2.65836 -2.06491e-19)
(1.70912 2.99273 -5.43444e-19)
(1.81113 3.39441 2.26848e-20)
(1.94688 3.83926 -6.16461e-19)
(2.04655 4.28036 -7.18601e-20)
(1.81116 4.68946 -1.21479e-18)
(1.6533 1.81714 5.8696e-19)
(1.68892 1.96722 -9.14968e-19)
(1.73251 2.1446 5.09166e-19)
(1.79295 2.35876 2.47311e-19)
(1.87365 2.62282 -6.4924e-20)
(1.97801 2.94776 7.76523e-19)
(2.11004 3.33449 -4.88415e-19)
(2.27627 3.75556 -1.31596e-18)
(2.40144 4.16586 -1.92411e-19)
(2.18291 4.55713 1.12028e-18)
(1.82889 1.77608 -4.21274e-21)
(1.87553 1.92497 4.5745e-19)
(1.93348 2.09935 -2.11993e-19)
(2.01254 2.30808 2.34814e-19)
(2.1155 2.5641 2.21266e-19)
(2.24569 2.87719 -3.91243e-19)
(2.40642 3.24624 2.88512e-19)
(2.60068 3.64087 -6.83147e-19)
(2.74787 4.0186 1.7929e-18)
(2.54342 4.39279 -6.10337e-19)
(2.00164 1.72128 -3.12498e-19)
(2.0586 1.86601 -1.44008e-19)
(2.13129 2.03494 6.5165e-19)
(2.22932 2.236 -9.42565e-19)
(2.35421 2.48179 9.41658e-19)
(2.5093 2.78061 -4.93014e-19)
(2.69706 3.12929 -8.35996e-19)
(2.91662 3.4949 1.96927e-19)
(3.08228 3.83861 -3.16634e-18)
(2.88966 4.19697 2.22174e-18)
(2.168 1.6505 8.38462e-19)
(2.23255 1.78811 -6.87969e-19)
(2.32219 1.95009 7.0775e-19)
(2.44023 2.14209 -5.93203e-20)
(2.58665 2.37574 -7.42717e-19)
(2.76553 2.6579 -3.85753e-19)
(2.97844 2.98363 4.36127e-19)
(3.22038 3.31797 1.20328e-18)
(3.40099 3.62681 1.5372e-18)
(3.21843 3.97155 1.47494e-20)
(-0.180017 0.809341 2.3493e-19)
(-0.297553 0.876846 -1.65735e-19)
(-0.445491 0.980875 5.51502e-20)
(-0.630462 1.12421 -1.17496e-19)
(-0.86183 1.31524 -6.59804e-20)
(-1.15253 1.56465 -7.02723e-20)
(-1.51346 1.88706 5.57207e-21)
(-1.94257 2.30589 6.54857e-20)
(-2.47324 2.78991 1.5102e-19)
(-3.28385 3.13559 -1.63379e-19)
(-0.147915 0.914117 -1.15027e-19)
(-0.259184 0.987782 -9.67148e-20)
(-0.396486 1.09746 1.77398e-19)
(-0.569841 1.24824 6.86499e-20)
(-0.786831 1.451 7.37297e-20)
(-1.05868 1.71745 -7.46588e-20)
(-1.39463 2.06214 -1.45996e-20)
(-1.78957 2.50653 -1.54168e-19)
(-2.27645 3.01872 -2.2428e-19)
(-3.04385 3.40423 4.15705e-19)
(-0.103818 1.01964 4.71981e-20)
(-0.209347 1.10099 -9.26608e-21)
(-0.336842 1.21699 1.64638e-19)
(-0.498041 1.37509 -1.05234e-19)
(-0.699568 1.58836 -4.15047e-20)
(-0.951194 1.86985 1.93985e-20)
(-1.2605 2.23418 -1.11827e-20)
(-1.61963 2.70055 3.11544e-19)
(-2.06138 3.23609 1.49949e-19)
(-2.78376 3.65561 -3.0673e-19)
(-0.0475773 1.12477 2.32664e-19)
(-0.147591 1.21391 -9.62777e-20)
(-0.265661 1.33684 3.35997e-20)
(-0.414283 1.50257 -2.22164e-20)
(-0.599428 1.72564 6.84609e-20)
(-0.829601 2.02046 -2.43902e-20)
(-1.11078 2.40188 -2.12957e-20)
(-1.43266 2.88672 4.03159e-20)
(-1.82829 3.44092 2.43855e-21)
(-2.50449 3.88856 4.66539e-19)
(0.0208232 1.22805 -1.60007e-19)
(-0.0732512 1.32489 -3.77792e-21)
(-0.1819 1.45508 4.19214e-20)
(-0.317603 1.62859 1.18149e-21)
(-0.485659 1.86092 -2.56172e-21)
(-0.69337 2.1676 -1.39477e-20)
(-0.945182 2.56371 3.74673e-20)
(-1.22864 3.06355 -4.64621e-20)
(-1.57744 3.63168 -6.03601e-21)
(-2.20684 4.1014 -5.78665e-19)
(0.101198 1.32828 7.48227e-21)
(0.0138903 1.43266 -5.25801e-20)
(-0.0850129 1.57006 3.49253e-20)
(-0.207375 1.75125 -3.8362e-21)
(-0.357696 1.99225 -1.34759e-20)
(-0.542077 2.30943 5.21946e-20)
(-0.763493 2.71791 2.74643e-20)
(-1.00767 3.22932 1.368e-20)
(-1.3093 3.80666 1.34708e-19)
(-1.89193 4.29245 1.1666e-19)
(0.193464 1.42409 3.05625e-20)
(0.113889 1.53577 -2.08936e-20)
(0.0252314 1.68014 -2.06852e-21)
(-0.0832817 1.86866 2.76368e-20)
(-0.215232 2.11766 -2.80936e-20)
(-0.375508 2.44398 3.82739e-20)
(-0.565679 2.86257 -4.8651e-20)
(-0.769988 3.38215 1.6858e-19)
(-1.02456 3.96405 1.90195e-19)
(-1.56112 4.46012 2.84522e-19)
(0.297462 1.51397 3.02402e-21)
(0.226619 1.63259 5.73804e-21)
(0.148805 1.78355 -5.99615e-21)
(0.0547181 1.97893 -7.92469e-21)
(-0.058221 2.23512 4.21676e-20)
(-0.193688 2.5692 -7.19434e-20)
(-0.351925 2.99563 -7.62461e-20)
(-0.51606 3.52003 3.26686e-19)
(-0.724112 4.10198 -7.6233e-20)
(-1.21599 4.60292 -3.2006e-19)
(0.412858 1.59633 -1.01461e-20)
(0.351734 1.72143 6.26944e-21)
(0.285414 1.87853 2.94585e-21)
(0.206378 2.08015 -1.48639e-21)
(0.113095 2.34263 -2.8239e-20)
(0.00308064 2.683 1.16865e-19)
(-0.12267 3.115 -1.47528e-19)
(-0.246552 3.64089 -3.0858e-20)
(-0.408993 4.21849 -6.62854e-22)
(-0.858182 4.71934 -2.70806e-19)
(0.539163 1.66957 8.58701e-21)
(0.488685 1.80059 1.70309e-21)
(0.434529 1.96325 -3.34151e-21)
(0.371194 2.17037 -8.78422e-21)
(0.298206 2.43809 -2.54564e-20)
(0.214219 2.78317 2.14381e-20)
(0.121343 3.2184 1.4156e-20)
(0.0375083 3.74246 3.3987e-20)
(-0.0806724 4.31163 -5.99822e-20)
(-0.489974 4.80818 5.78041e-20)
(-0.185966 0.691746 3.04345e-19)
(-0.21086 0.601962 -1.36838e-19)
(-0.229405 0.512559 4.09425e-20)
(-0.245918 0.429978 2.41759e-19)
(-0.260256 0.355603 1.54548e-19)
(-0.273343 0.289467 1.35539e-20)
(-0.286439 0.230905 7.75719e-20)
(-0.300487 0.178677 1.52668e-20)
(-0.316006 0.131101 2.5632e-20)
(-0.333074 0.086187 -1.04857e-20)
(-0.321003 0.769862 1.35506e-19)
(-0.347215 0.674823 1.54573e-19)
(-0.368576 0.579353 1.67389e-19)
(-0.38785 0.490603 -5.2142e-20)
(-0.404803 0.409882 -7.98638e-20)
(-0.420187 0.337058 -1.30474e-19)
(-0.434942 0.271329 5.92085e-20)
(-0.449767 0.211402 -1.92795e-19)
(-0.465027 0.155647 -1.69274e-20)
(-0.480737 0.102226 1.56203e-20)
(-0.48324 0.869742 -4.01511e-19)
(-0.514688 0.766206 6.70113e-20)
(-0.541178 0.66388 -3.12096e-19)
(-0.564575 0.567657 -9.16077e-20)
(-0.584946 0.47858 2.96428e-19)
(-0.602946 0.396534 1.83038e-19)
(-0.619249 0.320762 7.04232e-20)
(-0.634342 0.250098 -2.96543e-20)
(-0.648467 0.183127 6.76666e-20)
(-0.661617 0.118301 -9.85672e-21)
(-0.67994 1.00445 -9.36126e-20)
(-0.720614 0.889099 -1.71307e-19)
(-0.755103 0.776132 -2.65502e-20)
(-0.784737 0.668537 -9.79316e-20)
(-0.809893 0.567015 -1.61861e-19)
(-0.831165 0.471489 -1.48701e-20)
(-0.849065 0.381366 -9.6866e-20)
(-0.863961 0.295735 -4.61396e-20)
(-0.876046 0.213501 -7.96755e-20)
(-0.885361 0.133477 8.85967e-21)
(-0.925013 1.18198 -1.89198e-19)
(-0.978164 1.05117 2.4194e-19)
(-1.0232 0.922763 2.46912e-20)
(-1.06116 0.798649 -3.88831e-20)
(-1.09257 0.67937 6.11298e-20)
(-1.11794 0.564968 9.95869e-20)
(-1.13768 0.455112 1.67665e-19)
(-1.15212 0.349236 -1.2335e-19)
(-1.16144 0.246643 1.58045e-20)
(-1.16579 0.146568 6.26887e-22)
(-1.23333 1.41232 1.9929e-19)
(-1.30247 1.26096 -1.32101e-19)
(-1.36107 1.11112 -5.43037e-20)
(-1.40998 0.96413 -1.0373e-20)
(-1.4497 0.820546 -5.35114e-20)
(-1.48064 0.680627 7.81438e-20)
(-1.50315 0.544378 8.09828e-20)
(-1.51749 0.411647 1.22775e-20)
(-1.52391 0.282188 -1.93006e-20)
(-1.52262 0.155707 -1.3861e-20)
(-1.61747 1.71004 -2.12317e-20)
(-1.70764 1.53212 2.86083e-20)
(-1.78447 1.35401 6.96989e-21)
(-1.84858 1.17687 -5.04376e-20)
(-1.90036 1.00141 1.08059e-19)
(-1.9401 0.828149 1.29263e-20)
(-1.96803 0.657487 -7.15027e-20)
(-1.98436 0.489722 -2.2783e-20)
(-1.98931 0.325095 -1.4325e-20)
(-1.98314 0.163815 7.39295e-21)
(-2.0787 2.09988 -1.17725e-19)
(-2.19829 1.8902 -6.19797e-20)
(-2.30152 1.67762 6.78391e-20)
(-2.38872 1.46338 3.26218e-21)
(-2.4601 1.24837 -4.12556e-20)
(-2.51572 1.03344 -8.04386e-21)
(-2.55565 0.819385 3.51329e-20)
(-2.57995 0.606965 -4.17518e-20)
(-2.5887 0.396914 1.49215e-20)
(-2.5821 0.189933 -4.4175e-21)
(-2.65089 2.55074 -3.77982e-20)
(-2.80849 2.3039 1.87494e-19)
(-2.94666 2.0503 -1.59348e-19)
(-3.06526 1.79134 1.50687e-19)
(-3.16422 1.52816 -1.19188e-19)
(-3.24327 1.26194 1.0417e-20)
(-3.3022 0.993896 -4.22952e-20)
(-3.34084 0.72527 6.56958e-21)
(-3.35911 0.457274 8.62648e-21)
(-3.35694 0.191065 -5.10641e-22)
(-3.50171 2.85 1.12793e-19)
(-3.69412 2.55225 -3.38019e-19)
(-3.86356 2.2428 1.38315e-19)
(-4.0089 1.92354 -1.01885e-19)
(-4.1296 1.59604 6.25546e-20)
(-4.22507 1.26202 2.39413e-19)
(-4.2948 0.923251 3.05698e-20)
(-4.33847 0.581538 6.03869e-20)
(-4.35594 0.238695 -3.56451e-20)
(-4.34699 -0.103539 -6.83234e-21)
(-0.351385 0.0417626 -1.1589e-20)
(-0.370263 -0.00442882 4.31981e-20)
(-0.388745 -0.0545488 -1.81948e-19)
(-0.405785 -0.110617 1.19149e-19)
(-0.420262 -0.174391 -1.18178e-20)
(-0.430985 -0.247276 7.76493e-20)
(-0.436659 -0.330375 -4.03948e-19)
(-0.435555 -0.424682 -1.01339e-20)
(-0.423121 -0.529444 8.63554e-20)
(-0.390731 -0.642785 -1.78962e-19)
(-0.496628 0.0491925 -3.24485e-20)
(-0.512139 -0.0054351 7.60739e-20)
(-0.526469 -0.0635153 6.9756e-20)
(-0.538773 -0.126783 4.19488e-20)
(-0.548093 -0.196766 9.91717e-20)
(-0.55333 -0.274722 1.92287e-21)
(-0.553197 -0.361698 3.20621e-20)
(-0.545755 -0.4585 -4.95659e-20)
(-0.52632 -0.564577 -1.72705e-19)
(-0.488356 -0.681723 4.76786e-20)
(-0.673605 0.0540014 1.99073e-20)
(-0.684032 -0.0114067 -1.39359e-19)
(-0.69228 -0.0794442 -2.6436e-20)
(-0.697724 -0.151557 1.18331e-20)
(-0.699592 -0.229053 -1.08447e-19)
(-0.696914 -0.313082 -4.58244e-20)
(-0.688457 -0.404676 -7.35539e-20)
(-0.672392 -0.504652 7.93524e-20)
(-0.64532 -0.61322 1.18509e-19)
(-0.603689 -0.733563 2.27907e-19)
(-0.89186 0.0544217 -2.0855e-20)
(-0.895349 -0.0249387 6.25903e-20)
(-0.895413 -0.105789 -6.70265e-20)
(-0.89168 -0.189305 1.42196e-19)
(-0.883612 -0.276605 7.4989e-20)
(-0.870477 -0.368756 3.62359e-20)
(-0.851286 -0.466811 1.37663e-19)
(-0.824611 -0.571712 5.81741e-20)
(-0.788368 -0.684287 -7.81955e-21)
(-0.741109 -0.807335 -6.4568e-20)
(-1.16529 0.0481838 -6.98331e-21)
(-1.15999 -0.0493982 1.07795e-21)
(-1.1497 -0.147016 -4.37015e-20)
(-1.13435 -0.24557 -1.08955e-19)
(-1.1137 -0.345984 1.81205e-20)
(-1.08738 -0.449221 1.17635e-19)
(-1.0548 -0.556301 -1.88372e-19)
(-1.01508 -0.668237 5.02152e-20)
(-0.967143 -0.786126 1.02234e-20)
(-0.910479 -0.91207 -2.35518e-21)
(-1.51393 0.0318448 2.23719e-20)
(-1.49816 -0.0898583 -1.41464e-20)
(-1.47535 -0.209859 -5.42124e-20)
(-1.44575 -0.328736 5.72577e-20)
(-1.4095 -0.447165 -6.55365e-20)
(-1.36664 -0.565932 9.88218e-21)
(-1.31705 -0.685935 -6.83871e-21)
(-1.26043 -0.808141 -2.41708e-20)
(-1.19635 -0.933658 -1.37125e-20)
(-1.1247 -1.06401 1.28274e-20)
(-1.96627 0.00605437 -2.31097e-21)
(-1.9393 -0.1481 3.19719e-21)
(-1.90243 -0.298663 -5.0627e-20)
(-1.85627 -0.445791 5.98406e-20)
(-1.80134 -0.589805 1.1592e-19)
(-1.7381 -0.731183 -3.20364e-20)
(-1.66691 -0.87057 2.52111e-20)
(-1.588 -1.00874 -4.986e-21)
(-1.50147 -1.14662 -7.302e-21)
(-1.40745 -1.28528 2.31105e-20)
(-2.56047 -0.013199 -1.63514e-21)
(-2.52457 -0.211556 5.25177e-21)
(-2.47475 -0.404665 -1.18243e-20)
(-2.41189 -0.592102 -1.39763e-20)
(-2.33681 -0.773667 2.6601e-20)
(-2.25035 -0.949338 1.31788e-21)
(-2.15335 -1.1193 -1.33815e-20)
(-2.04652 -1.28392 -4.40136e-20)
(-1.93046 -1.44379 6.63905e-20)
(-1.80559 -1.5996 4.23257e-20)
(-3.33415 -0.0718792 -1.60907e-21)
(-3.29143 -0.329294 3.21471e-20)
(-3.22942 -0.580382 2.49675e-20)
(-3.14903 -0.823949 -5.06968e-20)
(-3.05124 -1.05908 5.93433e-20)
(-2.93714 -1.285 -1.08932e-19)
(-2.8079 -1.50116 6.28686e-20)
(-2.66475 -1.70731 -6.48747e-20)
(-2.5088 -1.90353 -4.56588e-20)
(-2.34079 -2.09003 -2.09371e-19)
(-4.31065 -0.443233 -3.4356e-21)
(-4.24745 -0.775948 -4.05396e-20)
(-4.1586 -1.10151 3.84825e-20)
(-4.04472 -1.4177 3.44393e-20)
(-3.90671 -1.72273 -7.04151e-20)
(-3.74568 -2.01491 7.08463e-20)
(-3.56293 -2.29273 -1.15444e-19)
(-3.35997 -2.55503 9.72438e-20)
(-3.13846 -2.80103 -2.16439e-19)
(-2.8996 -3.03004 2.27598e-19)
(-2.6437 -3.24029 3.56741e-19)
(-2.16128 -2.26633 -1.35107e-19)
(-1.67226 -1.75173 -5.01297e-20)
(-1.3061 -1.42541 5.31458e-20)
(-1.04583 -1.20016 6.87895e-21)
(-0.846152 -1.04794 -3.44643e-20)
(-0.685008 -0.94529 -2.24588e-20)
(-0.550958 -0.876292 6.77333e-20)
(-0.437713 -0.832815 -1.7143e-19)
(-0.348777 -0.811449 1.72941e-20)
(-2.37546 -3.42855 -4.08456e-19)
(-1.97234 -2.43172 5.36299e-19)
(-1.53099 -1.90021 -6.99306e-20)
(-1.19714 -1.56668 -4.16633e-20)
(-0.959421 -1.34058 5.7255e-21)
(-0.774928 -1.18977 1.37011e-20)
(-0.623859 -1.08925 -4.39554e-20)
(-0.496952 -1.02233 8.1281e-20)
(-0.390658 -0.979281 5.43866e-21)
(-0.309267 -0.95363 -8.40962e-20)
(-2.09498 -3.59733 2.77439e-19)
(-1.77384 -2.58694 -2.96792e-19)
(-1.38086 -2.04508 1.22279e-19)
(-1.07894 -1.70875 -2.78772e-20)
(-0.862995 -1.48441 2.67911e-20)
(-0.693028 -1.33604 -2.12202e-20)
(-0.551634 -1.23714 7.54686e-21)
(-0.43137 -1.17014 -1.36113e-20)
(-0.32967 -1.12432 5.47091e-20)
(-0.249598 -1.0921 -1.01139e-19)
(-1.80381 -3.74584 -5.89508e-19)
(-1.56604 -2.73217 8.18141e-20)
(-1.22123 -2.18655 8.7873e-20)
(-0.950076 -1.85148 8.3706e-20)
(-0.754495 -1.63113 -1.39123e-19)
(-0.597772 -1.48607 -3.87222e-22)
(-0.464963 -1.38862 -1.12272e-20)
(-0.350216 -1.32069 2.96248e-20)
(-0.251411 -1.27116 -4.37496e-20)
(-0.170714 -1.23228 -4.19558e-20)
(-1.50318 -3.87385 4.54538e-19)
(-1.34888 -2.86756 8.02497e-20)
(-1.05116 -2.32452 1.71243e-19)
(-0.809061 -1.99437 1.00239e-20)
(-0.632075 -1.77982 1.27418e-19)
(-0.48713 -1.63862 5.68885e-20)
(-0.3618 -1.54236 4.87552e-20)
(-0.251774 -1.4729 -3.44225e-20)
(-0.155325 -1.41909 7.29902e-21)
(-0.0740231 -1.37323 2.44251e-20)
(-1.19431 -3.9811 3.44902e-19)
(-1.12221 -2.993 -2.49565e-19)
(-0.869673 -2.45859 -1.06878e-20)
(-0.654512 -2.13648 -4.30696e-20)
(-0.494238 -1.92904 -3.48088e-20)
(-0.359698 -1.79181 -2.69795e-20)
(-0.241018 -1.6962 5.30175e-20)
(-0.135418 -1.62441 -3.63057e-20)
(-0.0415806 -1.56559 3.03899e-20)
(0.0393707 -1.51216 -3.81059e-21)
(-0.878356 -4.06741 -6.32455e-19)
(-0.885778 -3.1082 -1.82801e-19)
(-0.675821 -2.58791 3.13213e-19)
(-0.485226 -2.27637 -8.32165e-20)
(-0.339846 -2.07675 8.50557e-20)
(-0.214616 -1.94313 -2.02734e-19)
(-0.102176 -1.84728 1.49207e-19)
(-0.00121666 -1.7721 -3.56526e-20)
(0.0891709 -1.70732 3.46886e-20)
(0.168239 -1.64558 -4.80793e-20)
(-0.556421 -4.13268 2.93031e-19)
(-0.639311 -3.21257 -8.90598e-20)
(-0.468742 -2.71122 -9.36156e-20)
(-0.300254 -2.41208 -3.96641e-20)
(-0.16817 -2.22041 2.87539e-20)
(-0.0515587 -2.08959 4.12997e-20)
(0.0545614 -1.99224 -6.05539e-20)
(0.150165 -1.91242 4.23799e-20)
(0.235818 -1.84066 7.51449e-20)
(0.311086 -1.76991 -6.87032e-20)
(-0.229486 -4.17685 2.51922e-19)
(-0.38249 -3.30526 -9.32734e-21)
(-0.247734 -2.82678 1.74952e-19)
(-0.0989887 -2.54115 -1.3482e-19)
(0.0210421 -2.357 4.02221e-20)
(0.12924 -2.22781 -4.16245e-20)
(0.22844 -2.12752 -1.20731e-20)
(0.31751 -2.04173 -6.34866e-20)
(0.396794 -1.96201 6.34377e-20)
(0.466118 -1.88179 4.26856e-20)
(0.101612 -4.19955 -5.20103e-20)
(-0.115018 -3.38492 -3.80006e-20)
(-0.0123592 -2.93242 -2.06355e-20)
(0.118733 -2.66074 -6.45573e-20)
(0.227501 -2.48326 5.73044e-20)
(0.326967 -2.35425 1.16147e-20)
(0.418143 -2.24956 -3.33922e-20)
(0.499095 -2.15657 2.39469e-21)
(0.570134 -2.06814 -1.14288e-20)
(0.631283 -1.97836 1.72489e-21)
(0.911018 -1.7192 -1.63776e-21)
(0.919092 -1.3426 -2.24467e-22)
(0.954263 -1.06497 6.39663e-22)
(0.96294 -0.848759 -1.17279e-22)
(0.96606 -0.681817 9.47943e-23)
(0.965796 -0.547869 1.66874e-22)
(0.962214 -0.438318 -7.5539e-23)
(0.957809 -0.347666 8.44196e-23)
(0.951173 -0.272914 -3.83116e-23)
(0.946741 -0.210651 1.1217e-23)
(0.939923 -0.161376 7.1168e-24)
(0.937453 -0.118371 2.08843e-23)
(0.934068 -0.089831 -1.24269e-23)
(0.931552 -0.0582618 -6.59608e-23)
(0.938767 -0.044357 9.58242e-24)
(0.930421 -0.0214773 -4.13712e-23)
(0.948841 -0.00360559 1.48964e-23)
(0.951154 -0.00413175 1.62423e-23)
(0.95044 0.0470393 -3.0608e-23)
(0.937863 0.046448 -1.51329e-23)
(1.04333 -1.7576 1.40936e-20)
(0.982729 -1.35638 2.69318e-21)
(0.987299 -1.07166 -1.93387e-21)
(0.98097 -0.853022 2.24218e-22)
(0.97389 -0.683909 -2.20734e-22)
(0.966761 -0.548695 -5.57204e-23)
(0.958303 -0.438402 1.88075e-23)
(0.950289 -0.347313 7.4868e-23)
(0.941022 -0.272414 -7.11957e-23)
(0.934582 -0.210122 -3.17054e-23)
(0.926279 -0.160904 -1.70369e-23)
(0.922721 -0.118136 1.11796e-22)
(0.918375 -0.0895662 -2.00406e-22)
(0.915422 -0.0585257 -8.5411e-23)
(0.921769 -0.0443881 5.4609e-23)
(0.913131 -0.0218871 5.93607e-23)
(0.931826 -0.00457498 -1.23465e-22)
(0.932978 -0.00415851 2.53619e-22)
(0.93144 0.0474911 7.1742e-23)
(0.921046 0.0468286 3.70183e-23)
(1.17533 -1.78409 -2.94062e-20)
(1.04865 -1.36789 1.28137e-20)
(1.02153 -1.07846 1.19402e-20)
(1.00015 -0.858097 -3.46063e-21)
(0.982698 -0.686841 2.38631e-22)
(0.968422 -0.550206 -4.02315e-22)
(0.954925 -0.439037 -7.90215e-23)
(0.943209 -0.347392 4.78174e-23)
(0.931262 -0.272244 8.68292e-24)
(0.922782 -0.209831 -1.49899e-23)
(0.912983 -0.160607 -3.01167e-23)
(0.908331 -0.118003 3.56297e-24)
(0.903026 -0.089377 2.4678e-22)
(0.899646 -0.0588177 -1.30112e-22)
(0.905088 -0.0444182 -1.53039e-22)
(0.896264 -0.0223431 1.8848e-22)
(0.915094 -0.00551283 -6.06946e-23)
(0.915032 -0.00412947 -1.50614e-22)
(0.912797 0.0478736 -2.6098e-22)
(0.904579 0.0471424 6.43961e-23)
(1.30629 -1.7993 -9.66793e-21)
(1.11769 -1.37737 2.51182e-20)
(1.05775 -1.08557 -1.00428e-20)
(1.02082 -0.86399 -2.33142e-21)
(0.992691 -0.690623 1.44419e-21)
(0.970927 -0.552416 -2.63109e-23)
(0.952195 -0.440234 2.08652e-22)
(0.936672 -0.347914 -5.22837e-23)
(0.921988 -0.272412 5.62537e-23)
(0.911427 -0.209783 1.35397e-22)
(0.900114 -0.160487 -3.17485e-22)
(0.894347 -0.117976 4.52451e-23)
(0.888076 -0.0892645 -4.44e-23)
(0.88427 -0.059136 2.25247e-22)
(0.888772 -0.0444514 5.99009e-23)
(0.879855 -0.0228402 -1.48597e-22)
(0.898675 -0.00641086 -1.31184e-22)
(0.897365 -0.00405012 -3.58533e-22)
(0.894562 0.0481839 4.04157e-22)
(0.888496 0.047388 -1.33767e-22)
(1.43548 -1.80324 3.9638e-21)
(1.1906 -1.38373 2.86386e-21)
(1.09663 -1.09213 2.68343e-22)
(1.04323 -0.870201 5.70115e-21)
(1.00402 -0.695048 2.66727e-21)
(0.974404 -0.555256 1.77974e-21)
(0.950219 -0.441973 -6.99363e-22)
(0.930775 -0.348874 2.06417e-22)
(0.913288 -0.272919 6.27702e-23)
(0.900597 -0.209979 2.29988e-22)
(0.887745 -0.160545 -4.2376e-23)
(0.880835 -0.118053 -4.49522e-22)
(0.873584 -0.0892289 -1.16421e-22)
(0.869339 -0.0594791 3.92568e-22)
(0.87287 -0.0444918 3.39169e-22)
(0.863938 -0.023375 -1.8101e-22)
(0.882595 -0.00726243 4.92982e-22)
(0.88002 -0.00393039 1.01995e-22)
(0.876784 0.0484137 1.41133e-22)
(0.872825 0.0475649 -6.68983e-24)
(1.56235 -1.7942 -9.98398e-20)
(1.26787 -1.38439 -1.34031e-20)
(1.13852 -1.09657 1.1734e-20)
(1.06742 -0.87592 -1.73003e-20)
(1.01674 -0.699736 -8.00381e-21)
(0.978939 -0.558546 -6.61605e-21)
(0.949088 -0.444166 1.05372e-21)
(0.925604 -0.350231 2.85975e-22)
(0.90524 -0.273742 -5.17802e-22)
(0.890366 -0.210408 -2.08709e-22)
(0.87594 -0.160774 -1.75027e-22)
(0.867853 -0.118232 4.57294e-22)
(0.859602 -0.089267 -2.32467e-22)
(0.854897 -0.0598437 -2.96253e-22)
(0.857428 -0.0445421 -2.18158e-22)
(0.848541 -0.0239411 3.77044e-22)
(0.866881 -0.0080623 5.0292e-23)
(0.863047 -0.00377911 2.13244e-22)
(0.859507 0.0485596 -2.68582e-22)
(0.857596 0.0476727 4.76407e-23)
(1.68661 -1.77198 1.06383e-19)
(1.3494 -1.38094 3.37623e-20)
(1.18336 -1.10066 -3.53887e-21)
(1.09325 -0.882184 2.49757e-20)
(1.03082 -0.705105 -7.90443e-21)
(0.984584 -0.562423 7.23155e-22)
(0.948868 -0.446853 3.7758e-21)
(0.921228 -0.351993 -5.4149e-22)
(0.897911 -0.274882 -1.63133e-21)
(0.880798 -0.211068 6.33864e-23)
(0.864759 -0.161171 -3.75088e-22)
(0.855454 -0.11851 6.33309e-22)
(0.846179 -0.0893778 -4.13508e-22)
(0.840985 -0.0602287 1.31729e-21)
(0.842491 -0.0446055 3.46327e-22)
(0.833694 -0.0245336 -6.27227e-22)
(0.85156 -0.00880738 -1.96322e-22)
(0.846491 -0.0036074 -6.89804e-22)
(0.842771 0.0486167 1.50639e-22)
(0.842832 0.0477114 -4.16691e-23)
(1.80697 -1.7488 1.4007e-19)
(1.43475 -1.3873 1.59657e-20)
(1.23157 -1.11363 -2.71003e-20)
(1.1211 -0.894003 -1.56582e-21)
(1.04646 -0.713663 -1.10088e-20)
(0.991483 -0.568163 3.94899e-21)
(0.949656 -0.450708 -4.39018e-21)
(0.917722 -0.354531 7.49956e-22)
(0.891363 -0.276551 1.5058e-22)
(0.87195 -0.212085 1.00551e-21)
(0.854251 -0.161813 -1.92083e-22)
(0.843685 -0.118934 -1.76948e-23)
(0.83336 -0.0895887 -3.78974e-22)
(0.827641 -0.0606526 -2.06511e-24)
(0.828102 -0.0446949 -8.67216e-22)
(0.819419 -0.0251563 -1.12794e-22)
(0.836658 -0.0095011 2.60425e-22)
(0.830399 -0.00343355 6.96917e-22)
(0.826613 0.0485751 -1.8619e-22)
(0.828556 0.0476805 5.64679e-23)
(1.91937 -1.74114 -1.71771e-20)
(1.52525 -1.41097 1.15199e-19)
(1.2855 -1.13839 -4.26374e-20)
(1.15251 -0.913154 -2.48628e-20)
(1.06449 -0.726975 2.05066e-21)
(1.00005 -0.577001 2.94887e-21)
(0.951672 -0.456578 -2.35693e-21)
(0.915216 -0.358391 8.82711e-22)
(0.885679 -0.279101 3.84102e-22)
(0.863885 -0.213682 -3.7294e-22)
(0.844467 -0.16284 -1.48082e-21)
(0.832591 -0.119594 6.61599e-22)
(0.821184 -0.0899529 -4.13361e-22)
(0.814899 -0.0611516 -2.13209e-22)
(0.814299 -0.044832 1.0816e-21)
(0.805741 -0.0258202 -1.2487e-23)
(0.822204 -0.0101544 -7.26441e-22)
(0.814816 -0.00327957 6.68244e-23)
(0.811065 0.0484206 -9.82561e-23)
(0.814788 0.0475777 3.32137e-23)
(2.02012 -1.69302 1.12486e-20)
(1.62203 -1.39533 1.40153e-19)
(1.34645 -1.13795 -2.48425e-20)
(1.18834 -0.919674 -2.86069e-20)
(1.08538 -0.735246 1.31464e-20)
(1.01062 -0.584015 1.49669e-20)
(0.955149 -0.461836 -7.28613e-21)
(0.913857 -0.362122 7.16321e-21)
(0.880956 -0.281676 -3.77404e-21)
(0.856672 -0.215343 2.82724e-21)
(0.835457 -0.163918 -5.97481e-22)
(0.822213 -0.120281 -8.83111e-22)
(0.809689 -0.0903335 -1.15543e-21)
(0.802794 -0.0616313 6.99376e-22)
(0.801118 -0.0449686 1.4133e-22)
(0.792677 -0.0264643 -4.40745e-22)
(0.808224 -0.0107479 5.32469e-22)
(0.799786 -0.00310839 -7.9911e-23)
(0.796153 0.0481991 3.35803e-23)
(0.801547 0.047407 -1.48507e-23)
(2.16035 -1.45049 0)
(1.75192 -1.24438 0)
(1.43061 -1.05327 0)
(1.23823 -0.880085 0)
(1.11524 -0.719053 0)
(1.0267 -0.577279 0)
(0.961425 -0.458963 0)
(0.913368 -0.360916 0)
(0.875727 -0.281094 0)
(0.847915 -0.214925 0)
(0.824091 -0.163564 0)
(0.808812 -0.120006 0)
(0.794586 -0.090059 0)
(0.786664 -0.0617031 0)
(0.783352 -0.0448416 0)
(0.774965 -0.0270442 0)
(0.788979 -0.0113624 0)
(0.779189 -0.0026204 0)
(0.775913 0.0480227 0)
(0.783686 0.0471035 0)
(2.10202 -1.18033 0)
(1.71971 -1.07779 0)
(1.42288 -0.931558 0)
(1.24338 -0.792194 0)
(1.12408 -0.66132 0)
(1.03223 -0.539498 0)
(0.961108 -0.433261 0)
(0.907634 -0.343233 0)
(0.865702 -0.268757 0)
(0.83434 -0.206322 0)
(0.80776 -0.157462 0)
(0.790181 -0.11593 0)
(0.773934 -0.0871934 0)
(0.764782 -0.0601636 0)
(0.759338 -0.04375 0)
(0.75116 -0.027069 0)
(0.762776 -0.0118262 0)
(0.751652 -0.00144049 0)
(0.749279 0.0478124 0)
(0.760356 0.046353 0)
(2.03414 -0.950138 0)
(1.72305 -0.92526 0)
(1.44543 -0.827912 0)
(1.25875 -0.717692 0)
(1.13233 -0.609296 0)
(1.03463 -0.503544 0)
(0.957393 -0.40736 0)
(0.898588 -0.324283 0)
(0.852639 -0.254852 0)
(0.817973 -0.196259 0)
(0.788871 -0.150068 0)
(0.769117 -0.110843 0)
(0.750934 -0.083517 0)
(0.740585 -0.0580232 0)
(0.732908 -0.0422987 0)
(0.725032 -0.026822 0)
(0.733605 -0.0120986 0)
(0.721618 1.77899e-05 0)
(0.720558 0.0472232 0)
(0.735294 0.0451402 0)
(1.93236 -0.748473 0)
(1.68402 -0.768663 0)
(1.43743 -0.712855 0)
(1.25631 -0.630052 0)
(1.12991 -0.544558 0)
(1.03108 -0.458329 0)
(0.950315 -0.375611 0)
(0.887003 -0.301462 0)
(0.837246 -0.238241 0)
(0.799325 -0.184311 0)
(0.767756 -0.141285 0)
(0.745809 -0.104745 0)
(0.725734 -0.0790496 0)
(0.71418 -0.0552811 0)
(0.704214 -0.0404762 0)
(0.696677 -0.0262494 0)
(0.701581 -0.0120922 0)
(0.689503 0.00165543 0)
(0.690168 0.0460252 0)
(0.708923 0.0433384 0)
(1.80648 -0.566322 0)
(1.61718 -0.611719 0)
(1.41127 -0.592071 0)
(1.24381 -0.536926 0)
(1.11992 -0.472328 0)
(1.0218 -0.404644 0)
(0.939708 -0.336606 0)
(0.87316 -0.272929 0)
(0.820054 -0.217206 0)
(0.779009 -0.169071 0)
(0.745005 -0.130081 0)
(0.720768 -0.0969157 0)
(0.698789 -0.0732839 0)
(0.685943 -0.0515948 0)
(0.67366 -0.03804 0)
(0.666395 -0.0251129 0)
(0.667128 -0.0116782 0)
(0.656035 0.00340534 0)
(0.65876 0.0439744 0)
(0.681894 0.0407524 0)
(1.66302 -0.414768 0)
(1.5244 -0.467092 0)
(1.36211 -0.470857 0)
(1.21651 -0.439401 0)
(1.10023 -0.393631 0)
(1.00559 -0.342973 0)
(0.924817 -0.290029 0)
(0.85703 -0.238134 0)
(0.801529 -0.191113 0)
(0.757741 -0.14983 0)
(0.721442 -0.115818 0)
(0.694848 -0.0868161 0)
(0.67095 -0.0657999 0)
(0.656646 -0.0466613 0)
(0.64204 -0.0347254 0)
(0.634834 -0.0231796 0)
(0.631158 -0.010756 0)
(0.62232 0.00507565 0)
(0.627268 0.040713 0)
(0.65513 0.0371392 0)
(1.51837 -0.291707 0)
(1.41963 -0.338515 0)
(1.29767 -0.353467 0)
(1.17785 -0.339931 0)
(1.07337 -0.310755 0)
(0.984262 -0.275164 0)
(0.90652 -0.236455 0)
(0.839258 -0.196864 0)
(0.782486 -0.159529 0)
(0.736506 -0.126045 0)
(0.698163 -0.0979583 0)
(0.669266 -0.0739395 0)
(0.643496 -0.0561947 0)
(0.627557 -0.0401627 0)
(0.610673 -0.0302161 0)
(0.603194 -0.0202309 0)
(0.59527 -0.00926613 0)
(0.589885 0.00630531 0)
(0.596975 0.0357894 0)
(0.629846 0.0322125 0)
(1.38873 -0.192099 0)
(1.31828 -0.227497 0)
(1.22874 -0.244281 0)
(1.13355 -0.241528 0)
(1.04284 -0.225399 0)
(0.960639 -0.202586 0)
(0.886774 -0.176552 0)
(0.82119 -0.14898 0)
(0.764189 -0.12197 0)
(0.716679 -0.0971318 0)
(0.676639 -0.0759158 0)
(0.645653 -0.0577112 0)
(0.618179 -0.0440047 0)
(0.600527 -0.0317019 0)
(0.581536 -0.0241221 0)
(0.57345 -0.016064 0)
(0.561911 -0.0072021 0)
(0.56072 0.00657893 0)
(0.569635 0.0287387 0)
(0.607568 0.0256364 0)
(1.28815 -0.109759 0)
(1.23559 -0.131529 0)
(1.16851 -0.143924 0)
(1.09258 -0.145319 0)
(1.01434 -0.13798 0)
(0.938894 -0.125555 0)
(0.868758 -0.110606 0)
(0.805123 -0.094359 0)
(0.74854 -0.077968 0)
(0.700158 -0.0625332 0)
(0.658869 -0.0491319 0)
(0.62621 -0.0375855 0)
(0.597367 -0.0287668 0)
(0.578161 -0.0208641 0)
(0.557448 -0.0160495 0)
(0.548605 -0.0105519 0)
(0.534493 -0.00461974 0)
(0.537385 0.00531459 0)
(0.547639 0.0191773 0)
(0.590135 0.017041 0)
(1.22925 -0.0361491 0)
(1.18556 -0.0434577 0)
(1.13041 -0.0479314 0)
(1.06552 -0.0488871 0)
(0.995115 -0.0468397 0)
(0.92422 -0.0429016 0)
(0.856606 -0.0380032 0)
(0.794384 -0.032615 0)
(0.738338 -0.0271018 0)
(0.689644 -0.021837 0)
(0.647695 -0.0172211 0)
(0.614047 -0.0132296 0)
(0.5844 -0.0101606 0)
(0.564177 -0.00739955 0)
(0.542424 -0.00574038 0)
(0.533021 -0.00372045 0)
(0.517582 -0.00159752 0)
(0.52327 0.00213714 0)
(0.534284 0.00687851 0)
(0.579808 0.00610772 0)
(2.9131 -0.0513281 1.53653e-20)
(2.90408 -0.221371 -1.64056e-20)
(2.88029 -0.392791 -1.59552e-19)
(2.84147 -0.564264 -2.80236e-20)
(2.78795 -0.734279 1.05654e-19)
(2.7187 -0.901925 1.0993e-19)
(2.63618 -1.06452 3.09532e-19)
(2.53406 -1.22558 -1.89178e-19)
(2.43271 -1.36816 2.70414e-20)
(2.29896 -1.55277 -6.26526e-20)
(2.62901 -0.0714732 -2.90949e-21)
(2.61753 -0.199136 -3.83646e-20)
(2.59713 -0.326929 1.1193e-19)
(2.56799 -0.45421 8.83117e-20)
(2.53094 -0.580079 1.15041e-19)
(2.48551 -0.704277 1.84783e-19)
(2.43537 -0.824497 1.06688e-19)
(2.37573 -0.944893 -3.11495e-20)
(2.32539 -1.04883 -1.91717e-19)
(2.25245 -1.19085 2.17983e-19)
(2.38477 -0.064805 7.03128e-21)
(2.37449 -0.159938 -1.15849e-20)
(2.35959 -0.254191 3.82552e-20)
(2.3405 -0.347342 1.9196e-21)
(2.31789 -0.439106 -2.06362e-20)
(2.29145 -0.529739 -1.57007e-19)
(2.26272 -0.618331 6.94246e-20)
(2.22771 -0.708366 -5.72596e-20)
(2.19504 -0.789854 2.61779e-19)
(2.1498 -0.899609 1.74087e-19)
(2.16196 -0.0569983 1.8426e-20)
(2.15441 -0.127065 9.13768e-21)
(2.14424 -0.196523 -1.54528e-20)
(2.13159 -0.265426 -6.01502e-20)
(2.1166 -0.333826 9.94643e-21)
(2.09898 -0.401988 2.24418e-20)
(2.07927 -0.46961 -6.34369e-20)
(2.05629 -0.538196 7.69208e-21)
(2.03473 -0.602413 -1.24935e-19)
(2.01067 -0.68268 -1.64531e-19)
(1.95136 -0.049042 -9.2904e-21)
(1.94618 -0.0998248 2.1336e-21)
(1.93941 -0.150304 7.05005e-21)
(1.93119 -0.200517 3.59822e-20)
(1.92167 -0.250485 4.85467e-22)
(1.91096 -0.300252 -4.31535e-20)
(1.89942 -0.349686 -9.45939e-21)
(1.88684 -0.399274 6.37289e-20)
(1.8747 -0.447004 2.84715e-21)
(1.86276 -0.503375 5.44096e-20)
(1.75869 -0.0412135 -1.50514e-21)
(1.75526 -0.0768949 -3.73789e-21)
(1.75089 -0.112396 -3.71213e-21)
(1.74571 -0.147728 1.93273e-20)
(1.73982 -0.182911 1.58319e-20)
(1.73329 -0.217985 3.5904e-20)
(1.7262 -0.252972 6.74641e-20)
(1.71854 -0.288043 -9.08712e-20)
(1.71074 -0.322656 7.32092e-20)
(1.70412 -0.361265 -1.80888e-20)
(1.59094 -0.033554 6.16902e-21)
(1.58839 -0.0577142 -1.55891e-21)
(1.58511 -0.0818108 -8.40114e-21)
(1.58118 -0.105853 -1.75678e-20)
(1.57665 -0.129856 -6.75985e-20)
(1.5716 -0.153834 1.71148e-20)
(1.56612 -0.177797 -3.01764e-20)
(1.56027 -0.201765 1.94405e-20)
(1.55426 -0.225639 -4.22302e-21)
(1.54917 -0.250909 -2.50167e-20)
(1.45401 -0.0256329 -1.39813e-21)
(1.45181 -0.0409943 -1.07557e-20)
(1.44889 -0.0563522 4.9804e-21)
(1.44531 -0.0717067 -5.54226e-21)
(1.44111 -0.0870583 -1.73575e-21)
(1.43636 -0.102407 -9.5465e-21)
(1.43112 -0.117749 -3.52994e-21)
(1.42544 -0.133083 -1.31774e-20)
(1.41945 -0.148401 1.59685e-20)
(1.41371 -0.164011 -1.11916e-20)
(1.35341 -0.0166441 2.2407e-21)
(1.35127 -0.0251075 -4.45611e-21)
(1.34836 -0.0335918 9.47038e-21)
(1.34472 -0.0420971 -2.34686e-20)
(1.34038 -0.0506223 1.76016e-20)
(1.33539 -0.0591647 1.52552e-21)
(1.3298 -0.0677197 -4.22835e-21)
(1.32365 -0.0762798 6.40521e-21)
(1.31702 -0.0848336 -3.85516e-21)
(1.31013 -0.0933492 1.26202e-21)
(1.29652 -0.00611648 -3.13753e-21)
(1.29435 -0.00880407 3.13051e-21)
(1.29138 -0.0115103 3.62644e-21)
(1.28762 -0.0142358 -2.87479e-21)
(1.2831 -0.0169796 -1.83622e-20)
(1.27785 -0.0197385 3.88049e-21)
(1.27189 -0.0225072 2.12574e-21)
(1.26527 -0.0252778 1.03612e-20)
(1.25801 -0.0280381 -2.655e-20)
(1.2502 -0.0307492 -8.06868e-21)
(2.32346 1.2664 1.27119e-19)
(2.41536 1.2007 -6.56309e-20)
(2.49512 1.10637 1.48299e-19)
(2.58878 0.992562 -2.57597e-19)
(2.67407 0.867714 -1.56017e-19)
(2.74528 0.733331 -6.21955e-20)
(2.80466 0.589599 5.81801e-20)
(2.85228 0.437772 1.80216e-19)
(2.88685 0.27945 1.64646e-20)
(2.90729 0.116008 -2.90078e-20)
(2.27947 1.06911 -3.40513e-19)
(2.34748 0.977007 1.85588e-19)
(2.382 0.877736 4.1048e-20)
(2.43868 0.76977 -1.0403e-19)
(2.49812 0.657137 -2.31537e-19)
(2.54484 0.542299 6.04407e-20)
(2.57986 0.424791 -8.39913e-20)
(2.60599 0.304168 -1.29235e-19)
(2.6233 0.180817 2.65689e-20)
(2.63104 0.0553858 1.08236e-20)
(2.19828 0.84674 -2.29088e-19)
(2.24507 0.761359 -3.09037e-19)
(2.25428 0.67689 1.55302e-20)
(2.28291 0.590142 1.9341e-19)
(2.32111 0.500039 2.01146e-19)
(2.35111 0.408309 -1.46325e-19)
(2.37044 0.315574 5.27551e-20)
(2.38253 0.221599 -3.66002e-20)
(2.389 0.126512 -1.58574e-20)
(2.38976 0.0308411 3.36274e-21)
(2.0726 0.637401 2.21243e-19)
(2.1032 0.567983 1.70112e-19)
(2.10061 0.501503 -9.93702e-21)
(2.11138 0.435479 -1.29086e-19)
(2.13303 0.367152 -3.16972e-20)
(2.15127 0.2971 -2.64841e-21)
(2.1617 0.226468 7.17818e-20)
(2.16663 0.155604 4.15703e-21)
(2.16812 0.0845799 -8.26151e-21)
(2.16658 0.0136152 -1.14256e-20)
(1.91261 0.463127 -1.08111e-19)
(1.93185 0.410074 4.46685e-20)
(1.92653 0.35959 -8.99585e-20)
(1.92863 0.310461 -2.80845e-20)
(1.93922 0.260229 3.80015e-21)
(1.94933 0.208715 4.12071e-20)
(1.95492 0.156799 -3.89414e-20)
(1.95686 0.105004 2.17436e-20)
(1.95667 0.053418 -1.62609e-20)
(1.95485 0.00205206 9.78696e-21)
(1.73925 0.322391 5.09177e-21)
(1.75102 0.28396 -6.40714e-20)
(1.74773 0.247234 6.00679e-20)
(1.74798 0.211841 1.85247e-20)
(1.75321 0.1762 1.13503e-20)
(1.75872 0.139895 -2.44466e-20)
(1.76191 0.10334 1.10711e-20)
(1.76292 0.0669053 -4.46123e-20)
(1.76254 0.030683 1.93774e-20)
(1.76112 -0.00535228 -3.43289e-21)
(1.57444 0.211464 4.27039e-20)
(1.58235 0.185634 2.79688e-20)
(1.58234 0.160751 -2.46944e-20)
(1.58371 0.136701 2.49283e-20)
(1.58722 0.112661 -1.06618e-20)
(1.59072 0.0883227 3.71815e-20)
(1.59293 0.0638255 3.87619e-21)
(1.59381 0.0393534 -5.23274e-21)
(1.59368 0.0149717 -6.53762e-21)
(1.5927 -0.00932652 5.20943e-21)
(1.43516 0.127828 -7.3978e-21)
(1.44167 0.112017 7.22648e-21)
(1.44427 0.096604 2.26838e-20)
(1.44703 0.0815299 -2.90138e-20)
(1.45027 0.0664419 4.48974e-20)
(1.45312 0.0512008 -9.37637e-21)
(1.45506 0.0358537 -1.22788e-20)
(1.45603 0.0204756 2.35278e-20)
(1.45615 0.00510054 -6.49551e-21)
(1.45547 -0.010268 6.7394e-22)
(1.33216 0.0666663 1.37399e-20)
(1.33835 0.0582879 -1.5199e-20)
(1.34241 0.0500254 -1.21682e-20)
(1.34601 0.0418511 -4.01935e-21)
(1.34934 0.0336414 7.5196e-21)
(1.35206 0.0253534 9.31665e-21)
(1.35399 0.0170056 -2.68266e-20)
(1.35507 0.00862404 1.57296e-20)
(1.35532 0.00022095 -6.64784e-21)
(1.35477 -0.00820152 1.99714e-23)
(1.27411 0.0202513 -8.60662e-21)
(1.28033 0.0175975 -1.5303e-20)
(1.28504 0.014972 -3.8783e-20)
(1.28899 0.0123683 -2.65445e-21)
(1.29238 0.00975842 2.90217e-20)
(1.29509 0.00713439 -1.13856e-20)
(1.29702 0.00450027 1.96936e-21)
(1.29813 0.00185968 3.37166e-21)
(1.29841 -0.000787886 2.62817e-21)
(1.29788 -0.00344543 -3.12156e-21)
(1.00071 0.0442539 0)
(1.00777 0.135302 0)
(1.02427 0.229553 0)
(1.04879 0.332923 0)
(1.08906 0.444122 0)
(1.14343 0.577895 0)
(1.22996 0.718835 0)
(1.35605 0.913377 0)
(1.55834 1.07134 0)
(1.9284 1.40467 0)
(1.00093 0.0421885 0)
(1.00949 0.128948 0)
(1.0288 0.218171 0)
(1.05681 0.316483 0)
(1.10371 0.418935 0)
(1.16367 0.545995 0)
(1.26447 0.664642 0)
(1.39612 0.85673 0)
(1.62331 0.9313 0)
(1.94206 1.27591 0)
(1.00101 0.0394858 0)
(1.01065 0.120537 0)
(1.03229 0.202749 0)
(1.06312 0.294046 0)
(1.11552 0.383402 0)
(1.17936 0.501275 0)
(1.28834 0.584068 0)
(1.42144 0.770053 0)
(1.63816 0.743806 0)
(1.92648 1.04117 0)
(1.00102 0.0360926 0)
(1.01147 0.110224 0)
(1.03442 0.183856 0)
(1.06753 0.267041 0)
(1.12172 0.340504 0)
(1.18959 0.449135 0)
(1.2922 0.492554 0)
(1.42936 0.665905 0)
(1.60176 0.579912 0)
(1.87233 0.798366 0)
(1.00092 0.0319216 0)
(1.01202 0.0977279 0)
(1.03481 0.161093 0)
(1.07001 0.234828 0)
(1.12067 0.29104 0)
(1.19304 0.387943 0)
(1.27711 0.402014 0)
(1.41527 0.545409 0)
(1.53876 0.45669 0)
(1.77874 0.587494 0)
(1.00073 0.0269813 0)
(1.01213 0.0829741 0)
(1.03337 0.134894 0)
(1.06947 0.196991 0)
(1.11357 0.23793 0)
(1.18564 0.316067 0)
(1.25196 0.318999 0)
(1.3763 0.416063 0)
(1.46651 0.35408 0)
(1.65703 0.413857 0)
(1.00055 0.0214374 0)
(1.01152 0.0661524 0)
(1.0307 0.106486 0)
(1.06474 0.154375 0)
(1.10309 0.184358 0)
(1.16651 0.238114 0)
(1.22208 0.2421 0)
(1.32013 0.293821 0)
(1.39005 0.258322 0)
(1.52554 0.274117 0)
(1.00049 0.0155579 0)
(1.01024 0.0479025 0)
(1.02744 0.076964 0)
(1.05676 0.109614 0)
(1.0907 0.131263 0)
(1.14126 0.162461 0)
(1.18921 0.168401 0)
(1.26021 0.189876 0)
(1.31524 0.170598 0)
(1.40407 0.166642 0)
(1.00048 0.00951559 0)
(1.00879 0.0290808 0)
(1.02404 0.046861 0)
(1.04831 0.0654102 0)
(1.07808 0.0787804 0)
(1.11744 0.0938871 0)
(1.15806 0.0984616 0)
(1.20882 0.105157 0)
(1.25246 0.094987 0)
(1.30931 0.0872122 0)
(1.00048 0.00323132 0)
(1.00776 0.00980751 0)
(1.02151 0.0158414 0)
(1.04245 0.0218248 0)
(1.06903 0.0263442 0)
(1.10179 0.0307266 0)
(1.13712 0.0322875 0)
(1.17684 0.0334856 0)
(1.21378 0.0301367 0)
(1.25433 0.0266581 0)
(1.00001 0.0450368 -2.42177e-22)
(0.999486 0.135308 4.07471e-22)
(0.998384 0.229118 -5.47472e-22)
(0.995435 0.329586 6.50012e-22)
(0.990328 0.440415 2.34905e-23)
(0.979967 0.564645 2.97244e-22)
(0.96236 0.713331 -8.03673e-23)
(0.93281 0.884939 -9.89445e-23)
(0.877688 1.12261 2.82299e-24)
(0.800307 1.3932 2.83625e-22)
(0.999942 0.0451223 5.10634e-22)
(1.00004 0.135703 -1.36204e-21)
(1.00061 0.229909 2.74496e-22)
(1.00051 0.331146 -2.74807e-21)
(0.999621 0.443076 1.09361e-21)
(0.996083 0.569296 -3.00768e-25)
(0.987184 0.720987 -2.55904e-21)
(0.973603 0.897301 8.18152e-22)
(0.937694 1.14417 1.23121e-21)
(0.903456 1.43003 -9.6017e-21)
(0.999884 0.0451795 -5.89483e-22)
(1.00062 0.136056 3.61477e-21)
(1.00286 0.230589 -1.70514e-21)
(1.00562 0.332518 -1.59416e-22)
(1.00901 0.445306 -9.29048e-22)
(1.01238 0.573322 -1.54484e-21)
(1.01249 0.727268 8.21455e-22)
(1.01545 0.907465 -2.63803e-21)
(0.999852 1.16116 1.17633e-20)
(1.01238 1.45732 -5.16455e-21)
(0.999849 0.0452103 1.81565e-21)
(1.00122 0.136366 -3.50742e-21)
(1.00515 0.23116 2.08675e-21)
(1.01075 0.333705 3.3892e-21)
(1.01852 0.447109 -6.87345e-22)
(1.02883 0.576741 1.85925e-21)
(1.03829 0.732124 3.94865e-22)
(1.05821 0.915474 3.55898e-21)
(1.06396 1.17326 1.63896e-21)
(1.12661 1.47442 -9.03588e-21)
(0.999842 0.0452172 -4.80186e-22)
(1.00186 0.136632 3.2002e-22)
(1.00749 0.231628 -4.2768e-22)
(1.01593 0.334712 -7.49505e-22)
(1.02816 0.448498 -9.54886e-22)
(1.04539 0.579581 2.91697e-22)
(1.06461 0.735521 4.67115e-22)
(1.10171 0.92144 8.6798e-22)
(1.1299 1.18006 5.36381e-21)
(1.24563 1.481 -1.72229e-20)
(0.999869 0.0452019 -6.49862e-23)
(1.00255 0.13685 9.52746e-22)
(1.00991 0.231992 1.22638e-22)
(1.02114 0.335536 1.76024e-22)
(1.03796 0.449492 6.59252e-23)
(1.06203 0.581862 -1.33225e-21)
(1.09151 0.73745 3.09146e-21)
(1.14574 0.925525 -2.41806e-22)
(1.19771 1.18098 -8.87573e-21)
(1.36889 1.47706 9.23667e-20)
(0.999933 0.0451678 -1.06476e-21)
(1.00329 0.137017 -2.73482e-22)
(1.0124 0.23226 -5.92083e-22)
(1.0264 0.336178 1.54397e-22)
(1.04791 0.450125 7.24062e-22)
(1.0787 0.583596 -1.59542e-21)
(1.11902 0.737943 2.14046e-21)
(1.19007 0.927914 2.71377e-21)
(1.26758 1.17525 5.37017e-20)
(1.49565 1.46344 -1.52185e-19)
(1.00003 0.0451243 6.54236e-22)
(1.00411 0.137162 5.74634e-22)
(1.01497 0.232494 1.33893e-22)
(1.03169 0.33671 -2.66167e-22)
(1.05794 0.450522 -1.00948e-21)
(1.09532 0.584847 4.44774e-21)
(1.14712 0.737153 2.80907e-22)
(1.23444 0.928808 -3.96904e-20)
(1.33998 1.16206 -3.6527e-21)
(1.62505 1.44025 -6.8862e-20)
(1.00018 0.0450785 5.21792e-24)
(1.00503 0.137317 3.13448e-24)
(1.01764 0.232785 -4.86336e-22)
(1.03698 0.337253 -5.86709e-22)
(1.06793 0.450869 -2.40834e-21)
(1.11166 0.585669 6.30444e-21)
(1.1755 0.7352 -2.19686e-20)
(1.2785 0.927766 2.91591e-20)
(1.41554 1.14142 1.51954e-20)
(1.75469 1.41776 -5.09827e-20)
(1.00038 0.0449495 -1.21279e-22)
(1.0061 0.137202 5.48237e-24)
(1.02039 0.232677 1.97691e-23)
(1.04215 0.337184 2.743e-21)
(1.07753 0.450365 8.52775e-22)
(1.12703 0.584984 -5.66919e-21)
(1.20295 0.730761 -1.37762e-20)
(1.32131 0.920974 6.26428e-20)
(1.49725 1.10369 1.56068e-20)
(1.89494 1.35624 -1.2024e-19)
(0.999806 0.0425471 -5.81946e-22)
(0.992114 0.128551 -2.95422e-22)
(0.974722 0.215148 -2.46381e-21)
(0.945581 0.303914 1.25082e-20)
(0.902455 0.394839 1.72377e-21)
(0.838093 0.488235 -1.40042e-20)
(0.748648 0.579829 -3.07681e-20)
(0.612578 0.664557 8.50478e-20)
(0.440716 0.720488 -6.50563e-21)
(0.132973 0.725446 -8.61065e-20)
(0.999996 0.0429685 -1.00703e-21)
(0.993181 0.129656 -2.39843e-21)
(0.977271 0.217263 -4.48015e-21)
(0.950308 0.307622 8.16105e-21)
(0.910332 0.40118 -1.52314e-20)
(0.849895 0.498873 1.87328e-20)
(0.76616 0.598099 -4.99013e-20)
(0.635488 0.695131 4.68005e-20)
(0.470321 0.774967 9.80596e-22)
(0.172794 0.803582 -1.42759e-20)
(1.00013 0.043297 4.55266e-21)
(0.994138 0.130452 1.08533e-20)
(0.979813 0.218886 -7.00401e-21)
(0.955211 0.310586 1.29511e-21)
(0.918638 0.406462 -4.53755e-22)
(0.862492 0.507932 2.62193e-20)
(0.784968 0.614225 2.20043e-20)
(0.660945 0.722352 -3.98275e-20)
(0.502713 0.824799 1.38943e-20)
(0.2161 0.878402 -8.26242e-21)
(1.00022 0.043606 -6.16739e-21)
(0.994996 0.131219 -1.04049e-20)
(0.982301 0.220459 -3.8036e-21)
(0.960183 0.313416 1.24292e-21)
(0.927195 0.411445 1.25705e-20)
(0.875661 0.516273 -2.06785e-20)
(0.804673 0.628959 -9.7461e-21)
(0.688493 0.746827 -1.03234e-20)
(0.538063 0.870329 3.98772e-20)
(0.265172 0.952422 -8.0569e-20)
(1.00027 0.0438955 2.29552e-21)
(0.995776 0.13196 -2.03006e-21)
(0.984731 0.222004 1.07299e-20)
(0.965189 0.316212 -3.27158e-22)
(0.935932 0.41638 1.0086e-20)
(0.88933 0.524435 -2.87797e-20)
(0.825146 0.643281 2.55773e-20)
(0.718028 0.770409 5.4348e-21)
(0.576712 0.914246 -9.69014e-21)
(0.320801 1.02661 3.26958e-20)
(1.00028 0.0441588 -2.03708e-21)
(0.996494 0.132647 -4.5815e-22)
(0.987106 0.223465 -2.46279e-21)
(0.970214 0.318895 -9.18944e-21)
(0.944808 0.421175 7.97483e-21)
(0.903483 0.532369 7.08383e-21)
(0.846378 0.657217 -4.14031e-21)
(0.749549 0.793323 -1.71921e-20)
(0.618813 0.956605 6.38339e-21)
(0.383261 1.09938 -7.86423e-21)
(1.00027 0.0443939 2.01037e-21)
(0.997158 0.133278 -4.08197e-21)
(0.989428 0.224819 9.08796e-22)
(0.975249 0.321412 2.35183e-21)
(0.953787 0.42572 1.18922e-20)
(0.918085 0.539912 -6.07226e-22)
(0.86834 0.670479 2.38933e-21)
(0.782972 0.815092 7.66041e-21)
(0.664335 0.996532 -2.01531e-21)
(0.452736 1.16908 -3.01857e-21)
(1.00023 0.0445998 -1.34979e-21)
(0.997778 0.133857 4.49672e-21)
(0.991706 0.226062 7.26131e-22)
(0.980286 0.323745 -5.40765e-21)
(0.962839 0.429954 -1.35377e-21)
(0.933084 0.546962 -4.04078e-21)
(0.890973 0.682842 -4.2045e-21)
(0.818155 0.835335 5.76121e-21)
(0.71317 1.03343 1.0036e-20)
(0.529306 1.23446 -7.39341e-21)
(1.00016 0.0447759 4.39926e-22)
(0.998364 0.134386 -2.04629e-21)
(0.993949 0.227194 8.20481e-22)
(0.985327 0.325887 -6.44372e-22)
(0.971948 0.433834 -7.09939e-21)
(0.948428 0.55346 1.5365e-21)
(0.91422 0.694172 3.49625e-21)
(0.854949 0.853833 -6.31255e-21)
(0.765159 1.06695 1.7498e-21)
(0.612906 1.29438 5.14792e-22)
(1.00009 0.0449215 -4.33195e-22)
(0.99893 0.13487 2.0931e-22)
(0.99617 0.228213 -1.10031e-22)
(0.990375 0.327834 6.36645e-22)
(0.981109 0.437329 6.48952e-22)
(0.96407 0.559362 -3.53349e-22)
(0.938029 0.704365 6.03911e-23)
(0.893214 0.870416 8.03308e-22)
(0.820086 1.09678 -5.16287e-22)
(0.703342 1.34766 -2.57597e-22)
(0.999582 0.00267871 0)
(0.993828 0.00790426 0)
(0.982825 0.0127096 0)
(0.966593 0.0168194 0)
(0.94596 0.0199472 0)
(0.922063 0.0218603 0)
(0.89673 0.0222565 0)
(0.871179 0.021098 0)
(0.848433 0.0179752 0)
(0.827981 0.0136325 0)
(0.999517 0.00796792 0)
(0.99285 0.0235509 0)
(0.980105 0.0379937 0)
(0.96128 0.0505105 0)
(0.937258 0.0602494 0)
(0.909091 0.0664698 0)
(0.878966 0.0682047 0)
(0.847687 0.0652216 0)
(0.820169 0.0561655 0)
(0.792144 0.0433385 0)
(0.999422 0.0132187 0)
(0.991447 0.0391508 0)
(0.976169 0.0634474 0)
(0.953459 0.0849039 0)
(0.924164 0.102136 0)
(0.88913 0.113814 0)
(0.850954 0.118169 0)
(0.809859 0.114437 0)
(0.773689 0.100053 0)
(0.73191 0.0788198 0)
(0.999328 0.0184763 0)
(0.990056 0.0548515 0)
(0.972179 0.0893405 0)
(0.9453 0.120451 0)
(0.910041 0.146356 0)
(0.866834 0.165086 0)
(0.818426 0.173914 0)
(0.764422 0.171038 0)
(0.715852 0.152273 0)
(0.654675 0.122356 0)
(0.999256 0.023575 0)
(0.988973 0.0701688 0)
(0.968947 0.114888 0)
(0.938391 0.156137 0)
(0.897482 0.191807 0)
(0.845951 0.219359 0)
(0.786188 0.234995 0)
(0.717011 0.235349 0)
(0.652229 0.213967 0)
(0.565825 0.175257 0)
(0.999221 0.0283047 0)
(0.988361 0.084479 0)
(0.966933 0.139035 0)
(0.933702 0.190499 0)
(0.888227 0.236705 0)
(0.829217 0.27475 0)
(0.758097 0.299789 0)
(0.672387 0.306564 0)
(0.587682 0.285464 0)
(0.46948 0.238685 0)
(0.999225 0.0325025 0)
(0.988249 0.0972845 0)
(0.966267 0.160877 0)
(0.931598 0.222177 0)
(0.88311 0.2792 0)
(0.81822 0.32903 0)
(0.73685 0.365985 0)
(0.634339 0.383016 0)
(0.526593 0.366367 0)
(0.369139 0.313881 0)
(0.999261 0.0360927 0)
(0.988573 0.108371 0)
(0.966826 0.179962 0)
(0.931971 0.25035 0)
(0.882202 0.317929 0)
(0.813489 0.380197 0)
(0.723942 0.431023 0)
(0.605594 0.462303 0)
(0.472923 0.455424 0)
(0.268217 0.40195 0)
(0.999332 0.039098 0)
(0.989292 0.11789 0)
(0.968458 0.196574 0)
(0.934533 0.275365 0)
(0.885175 0.353122 0)
(0.814862 0.428114 0)
(0.719936 0.494093 0)
(0.587951 0.54306 0)
(0.430171 0.551731 0)
(0.170111 0.504528 0)
(0.999507 0.0415366 0)
(0.990561 0.125714 0)
(0.971283 0.210507 0)
(0.939341 0.297012 0)
(0.892125 0.384739 0)
(0.822706 0.473206 0)
(0.726078 0.556572 0)
(0.584139 0.627983 0)
(0.403579 0.658235 0)
(0.0803469 0.631891 0)
(0.820276 0.00924869 -1.26125e-20)
(0.817945 0.00748328 -3.60076e-20)
(0.816211 0.00574821 -6.3602e-20)
(0.814906 0.00403596 2.99036e-21)
(0.814038 0.00233365 3.14337e-20)
(0.813654 0.000636 -2.41236e-20)
(0.813777 -0.00106018 -3.66071e-21)
(0.814414 -0.00275939 4.70367e-21)
(0.81557 -0.00446736 4.00417e-21)
(0.817245 -0.00619002 -4.01956e-21)
(0.783899 0.029904 2.18614e-21)
(0.782048 0.024581 -4.9216e-21)
(0.78101 0.0193296 5.41219e-22)
(0.780218 0.0141258 -5.58903e-21)
(0.779716 0.00893341 2.37061e-20)
(0.779632 0.00374218 1.52297e-20)
(0.780013 -0.00145073 -2.95149e-20)
(0.780862 -0.00665163 1.19816e-20)
(0.782174 -0.0118704 -5.61249e-21)
(0.783947 -0.0171179 2.72153e-21)
(0.722599 0.0553497 -1.51764e-20)
(0.72158 0.0461123 1.98288e-20)
(0.721808 0.0370055 -8.32848e-21)
(0.721969 0.0279881 -5.27468e-21)
(0.722165 0.0190026 -1.02006e-20)
(0.722676 0.0100378 6.45456e-21)
(0.723579 0.00109302 -6.58726e-21)
(0.724853 -0.00783935 6.66831e-21)
(0.726477 -0.016772 -1.25699e-20)
(0.728435 -0.0257177 -1.67374e-21)
(0.643628 0.0871731 -2.92312e-20)
(0.643707 0.0733087 -4.17656e-21)
(0.645686 0.0596725 5.40813e-20)
(0.647188 0.0462091 3.86697e-21)
(0.648417 0.0328484 2.07704e-20)
(0.649849 0.0195868 -4.52351e-20)
(0.651581 0.00643139 -1.84828e-20)
(0.653543 -0.00661966 -7.22422e-21)
(0.655668 -0.0195697 -1.71064e-21)
(0.657898 -0.0324152 6.4358e-21)
(0.551902 0.126126 -1.33808e-20)
(0.553171 0.106598 7.09136e-20)
(0.557248 0.0874389 -8.82792e-20)
(0.560424 0.0686042 -2.07061e-20)
(0.563032 0.0500441 3.61102e-20)
(0.565747 0.0317927 2.52511e-20)
(0.568626 0.0138946 1.93081e-20)
(0.571486 -0.00360873 -2.74459e-21)
(0.57414 -0.0206649 -2.88364e-21)
(0.576394 -0.0372048 -1.59006e-21)
(0.450755 0.172923 6.07432e-20)
(0.452978 0.146365 -3.81221e-21)
(0.459245 0.120348 7.52939e-20)
(0.464278 0.0949325 3.87586e-20)
(0.468515 0.0701883 -3.43721e-20)
(0.472738 0.0462724 -6.16332e-21)
(0.476831 0.0233453 2.79759e-20)
(0.480365 0.00156656 6.04869e-21)
(0.482911 -0.0189006 2.40137e-21)
(0.484024 -0.0379095 -6.96653e-21)
(0.34246 0.228955 -1.33203e-19)
(0.344674 0.193839 -9.06113e-20)
(0.352504 0.159458 1.17039e-20)
(0.35896 0.126199 7.97418e-20)
(0.364466 0.094453 1.81028e-20)
(0.369701 0.0646243 9.49568e-21)
(0.374183 0.0370477 -4.19375e-20)
(0.377126 0.0119959 -9.2814e-21)
(0.377794 -0.0103493 5.90782e-21)
(0.375512 -0.0299574 1.2378e-20)
(0.22838 0.297721 1.42398e-19)
(0.228071 0.253313 1.63139e-19)
(0.23513 0.20962 -3.58143e-20)
(0.240993 0.167688 -1.00552e-19)
(0.245905 0.128521 -8.542e-20)
(0.250168 0.0928708 4.44036e-20)
(0.252837 0.061214 6.24931e-21)
(0.2528 0.0337686 2.16815e-20)
(0.249151 0.0104442 -7.49572e-21)
(0.241217 -0.00921308 3.03328e-21)
(0.106557 0.386588 1.28367e-19)
(0.097589 0.332674 -1.12296e-19)
(0.0983026 0.278764 -3.68473e-20)
(0.0995487 0.227459 4.9172e-20)
(0.100816 0.180531 1.03105e-19)
(0.1015 0.138875 -1.6275e-20)
(0.100098 0.10277 4.47422e-20)
(0.0953121 0.0720079 4.46193e-20)
(0.0863128 0.0458955 -1.71063e-20)
(0.0727218 0.0232752 -1.9272e-21)
(-0.0217747 0.54411 -2.00511e-19)
(-0.0475038 0.479877 -3.77235e-20)
(-0.0589616 0.40903 8.95901e-20)
(-0.0677507 0.340369 -2.09847e-19)
(-0.0754572 0.277795 -4.36143e-20)
(-0.083064 0.222463 -4.7606e-20)
(-0.0920342 0.174264 5.54826e-21)
(-0.103453 0.132351 -5.93703e-20)
(-0.117885 0.0952931 2.32352e-20)
(-0.135395 0.0612104 -1.26616e-20)
(0.819441 -0.00793283 -3.96057e-21)
(0.822154 -0.00970039 3.34207e-21)
(0.825377 -0.0114962 4.25562e-21)
(0.8291 -0.0133225 2.4144e-21)
(0.83331 -0.0151795 -7.44154e-21)
(0.837991 -0.0170657 3.12982e-20)
(0.843124 -0.0189771 -3.26669e-21)
(0.848684 -0.0209047 2.65083e-20)
(0.854641 -0.0228297 -1.94054e-20)
(0.860984 -0.0247021 -9.55289e-21)
(0.786175 -0.0224045 6.94294e-23)
(0.788848 -0.0277398 -8.05262e-21)
(0.791945 -0.0331315 1.90359e-20)
(0.795443 -0.0385851 -3.27285e-20)
(0.799308 -0.0441028 -3.04445e-20)
(0.803504 -0.0496828 1.52154e-20)
(0.807987 -0.0553178 -4.69707e-21)
(0.812701 -0.0609884 -7.17463e-21)
(0.817551 -0.06665 -1.87519e-20)
(0.822555 -0.0721848 1.42972e-20)
(0.730706 -0.0346865 8.3262e-22)
(0.733253 -0.0436846 -7.38569e-21)
(0.736025 -0.0527129 2.59192e-20)
(0.738955 -0.0617659 -1.3904e-20)
(0.741962 -0.0708319 -1.89805e-20)
(0.744953 -0.0798935 4.95619e-20)
(0.747833 -0.0889295 -3.17712e-20)
(0.750477 -0.0979116 1.78842e-20)
(0.752648 -0.10681 8.32094e-21)
(0.754428 -0.115603 -8.16562e-21)
(0.660147 -0.0451424 5.48019e-21)
(0.6623 -0.0577272 -6.70428e-21)
(0.664209 -0.0701365 -7.2411e-21)
(0.665701 -0.082333 3.43729e-21)
(0.666584 -0.0942841 1.02991e-20)
(0.666673 -0.105973 -1.32064e-20)
(0.665809 -0.11741 6.18311e-20)
(0.663815 -0.128641 -5.58232e-20)
(0.66027 -0.139796 2.73368e-20)
(0.655426 -0.151221 3.3215e-20)
(0.578003 -0.0531491 -2.96042e-21)
(0.578674 -0.0684217 1.70449e-20)
(0.578089 -0.0829681 -4.12504e-20)
(0.575934 -0.0967802 8.99444e-21)
(0.571933 -0.109922 -3.20227e-20)
(0.565899 -0.122553 9.114e-21)
(0.557791 -0.134932 -6.59187e-20)
(0.547557 -0.147413 5.03079e-20)
(0.534706 -0.160536 -5.19382e-20)
(0.520061 -0.175198 -4.37441e-21)
(0.483221 -0.0553658 7.27549e-21)
(0.480026 -0.0712714 -1.34062e-20)
(0.474031 -0.085764 1.65248e-20)
(0.464958 -0.0991542 -2.79965e-20)
(0.452716 -0.111946 3.74786e-20)
(0.437477 -0.124828 6.75931e-22)
(0.419699 -0.138609 2.80381e-20)
(0.399677 -0.154139 -8.65043e-20)
(0.376878 -0.172445 4.01828e-20)
(0.353572 -0.194864 -7.30813e-20)
(0.369685 -0.047011 -7.58328e-21)
(0.359897 -0.0619544 -5.07664e-21)
(0.345992 -0.0755136 1.25121e-21)
(0.328117 -0.088687 4.57729e-20)
(0.306754 -0.102699 -4.72017e-21)
(0.282783 -0.118895 -2.23003e-20)
(0.257384 -0.13855 4.35534e-20)
(0.230959 -0.162693 -1.1126e-20)
(0.202333 -0.192466 9.89281e-20)
(0.176491 -0.229389 1.02517e-19)
(0.228609 -0.0260406 2.71433e-21)
(0.211328 -0.0412458 -7.58331e-21)
(0.189801 -0.0563431 -1.91606e-20)
(0.164834 -0.0730576 2.24951e-20)
(0.137568 -0.0931885 1.05815e-20)
(0.109543 -0.118436 9.38058e-20)
(0.0825193 -0.150147 -2.02509e-20)
(0.0565012 -0.189085 8.61361e-21)
(0.0286107 -0.235976 -1.46161e-19)
(0.00757181 -0.292237 -1.10313e-19)
(0.0546186 0.00258925 5.43202e-21)
(0.0325592 -0.0180361 1.09823e-20)
(0.00751753 -0.0406626 -4.7603e-20)
(-0.01926 -0.067411 -3.78138e-20)
(-0.046362 -0.100297 -5.14847e-20)
(-0.0721039 -0.141057 -1.06992e-19)
(-0.0945484 -0.190956 -3.64296e-20)
(-0.113911 -0.250421 3.34544e-20)
(-0.134724 -0.318828 8.14361e-20)
(-0.145022 -0.395035 -1.02665e-19)
(-0.155577 0.0279043 7.49749e-21)
(-0.177584 -0.0070192 -2.181e-20)
(-0.200231 -0.0459608 6.07325e-20)
(-0.222196 -0.0912006 5.58574e-21)
(-0.24214 -0.14471 3.46959e-20)
(-0.25871 -0.207964 3.87044e-20)
(-0.270419 -0.281816 1.76176e-19)
(-0.276905 -0.366202 -7.73928e-20)
(-0.281159 -0.458153 1.40391e-20)
(-0.273089 -0.548331 1.50117e-19)
(0.877773 -0.0286707 0)
(0.913245 -0.0344657 0)
(0.958414 -0.0388687 0)
(1.01108 -0.041653 0)
(1.07121 -0.0428346 0)
(1.1348 -0.0421253 0)
(1.20173 -0.0400556 0)
(1.2684 -0.0357618 0)
(1.32889 -0.0319929 0)
(1.39228 -0.0254277 0)
(1.43137 -0.0218808 0)
(1.49031 -0.0154406 0)
(1.50111 -0.0116762 0)
(1.54943 -0.00816491 0)
(1.54446 -0.00318143 0)
(1.56372 -0.00216851 0)
(1.56046 0.00204959 0)
(1.5476 0.00289223 0)
(1.5357 0.0063129 0)
(1.50357 0.00345378 0)
(0.837785 -0.0840953 0)
(0.875433 -0.101029 0)
(0.923519 -0.113318 0)
(0.978404 -0.120873 0)
(1.03982 -0.123646 0)
(1.10476 -0.121041 0)
(1.17247 -0.11421 0)
(1.23916 -0.10183 0)
(1.29993 -0.0901364 0)
(1.36074 -0.0718889 0)
(1.40148 -0.0612939 0)
(1.45564 -0.0429324 0)
(1.46918 -0.0330986 0)
(1.51479 -0.0222423 0)
(1.51031 -0.0091944 0)
(1.53143 -0.00641434 0)
(1.52983 0.00575789 0)
(1.51643 0.00775168 0)
(1.51199 0.0167069 0)
(1.48136 0.00961862 0)
(0.764947 -0.135304 0)
(0.804532 -0.161325 0)
(0.85605 -0.179308 0)
(0.914493 -0.190704 0)
(0.980504 -0.194655 0)
(1.05155 -0.190145 0)
(1.12453 -0.178308 0)
(1.19488 -0.15891 0)
(1.25801 -0.138955 0)
(1.31722 -0.111492 0)
(1.35999 -0.0935655 0)
(1.40783 -0.0655079 0)
(1.42522 -0.0514325 0)
(1.46521 -0.0328905 0)
(1.46234 -0.0154178 0)
(1.48502 -0.0105152 0)
(1.48421 0.00837333 0)
(1.47144 0.0103466 0)
(1.47657 0.023352 0)
(1.44602 0.0146772 0)
(0.655196 -0.178508 0)
(0.698386 -0.211876 0)
(0.758964 -0.237591 0)
(0.83077 -0.256715 0)
(0.913349 -0.264121 0)
(1.00019 -0.25792 0)
(1.08395 -0.239894 0)
(1.15993 -0.212321 0)
(1.22435 -0.182499 0)
(1.28062 -0.146288 0)
(1.32178 -0.12001 0)
(1.36174 -0.0842222 0)
(1.38057 -0.0663926 0)
(1.41214 -0.040615 0)
(1.41142 -0.021729 0)
(1.43338 -0.0138146 0)
(1.43206 0.00999685 0)
(1.42176 0.0108142 0)
(1.43465 0.027527 0)
(1.4025 0.0191698 0)
(0.505118 -0.212645 0)
(0.569494 -0.26023 0)
(0.658653 -0.304422 0)
(0.7616 -0.335541 0)
(0.871001 -0.343477 0)
(0.974943 -0.329722 0)
(1.06544 -0.299961 0)
(1.14115 -0.260364 0)
(1.20089 -0.218729 0)
(1.25021 -0.173796 0)
(1.28542 -0.139368 0)
(1.317 -0.0980607 0)
(1.33463 -0.0769815 0)
(1.35759 -0.0456733 0)
(1.35964 -0.0272856 0)
(1.37893 -0.015933 0)
(1.37732 0.0107786 0)
(1.37102 0.00983058 0)
(1.38856 0.030452 0)
(1.3545 0.0233375 0)
(0.332352 -0.253218 0)
(0.453613 -0.329841 0)
(0.589029 -0.396669 0)
(0.727834 -0.430253 0)
(0.857989 -0.426662 0)
(0.968626 -0.396547 0)
(1.05654 -0.350527 0)
(1.12541 -0.297558 0)
(1.17666 -0.24499 0)
(1.21774 -0.192985 0)
(1.24616 -0.152236 0)
(1.27104 -0.107597 0)
(1.28667 -0.0839858 0)
(1.30299 -0.0491001 0)
(1.30822 -0.0319372 0)
(1.32394 -0.0172403 0)
(1.3232 0.0107358 0)
(1.32138 0.00802252 0)
(1.34073 0.032763 0)
(1.30547 0.0271525 0)
(0.170672 -0.323158 0)
(0.374795 -0.432137 0)
(0.55342 -0.507275 0)
(0.71764 -0.526459 0)
(0.856341 -0.501521 0)
(0.964633 -0.451343 0)
(1.04521 -0.389124 0)
(1.10555 -0.324449 0)
(1.14857 -0.263311 0)
(1.18265 -0.206142 0)
(1.20551 -0.16088 0)
(1.22568 -0.114306 0)
(1.23936 -0.0886977 0)
(1.25115 -0.0517357 0)
(1.25929 -0.0357436 0)
(1.27124 -0.0181417 0)
(1.27239 0.0100129 0)
(1.27456 0.00589929 0)
(1.29366 0.0347226 0)
(1.25824 0.0305341 0)
(0.0420661 -0.430659 0)
(0.327128 -0.558184 0)
(0.536614 -0.621955 0)
(0.716071 -0.615587 0)
(0.856011 -0.565726 0)
(0.958521 -0.495614 0)
(1.03113 -0.418917 0)
(1.08368 -0.34449 0)
(1.11989 -0.276671 0)
(1.14844 -0.215584 0)
(1.16696 -0.167026 0)
(1.18372 -0.119224 0)
(1.19557 -0.0919973 0)
(1.20429 -0.0539555 0)
(1.21459 -0.0387827 0)
(1.22295 -0.0188811 0)
(1.22653 0.00883274 0)
(1.23166 0.00380556 0)
(1.24928 0.0364148 0)
(1.2146 0.0334391 0)
(-0.0530688 -0.57098 0)
(0.296926 -0.696711 0)
(0.530073 -0.734222 0)
(0.719268 -0.696948 0)
(0.856909 -0.6214 0)
(0.952457 -0.532505 0)
(1.01739 -0.443091 0)
(1.06308 -0.360463 0)
(1.09361 -0.287258 0)
(1.11763 -0.222984 0)
(1.13264 -0.171876 0)
(1.14667 -0.123128 0)
(1.15677 -0.0945371 0)
(1.16333 -0.0559844 0)
(1.17493 -0.0412117 0)
(1.1801 -0.0196199 0)
(1.18621 0.00739102 0)
(1.1932 0.00191863 0)
(1.20878 0.0378509 0)
(1.17547 0.0358731 0)
(-0.120378 -0.727264 0)
(0.27907 -0.838153 0)
(0.533277 -0.836931 0)
(0.727785 -0.766967 0)
(0.860429 -0.666887 0)
(0.948244 -0.561474 0)
(1.00582 -0.461652 0)
(1.04535 -0.372589 0)
(1.071 -0.295314 0)
(1.09114 -0.228607 0)
(1.10315 -0.175627 0)
(1.11486 -0.126173 0)
(1.12328 -0.0964894 0)
(1.12822 -0.0577752 0)
(1.14041 -0.0430859 0)
(1.14286 -0.0203354 0)
(1.1513 0.00592267 0)
(1.15924 0.000342547 0)
(1.17265 0.0390979 0)
(1.14108 0.0378962 0)
(-0.159175 -0.843412 -9.96045e-21)
(0.274214 -0.940567 5.4968e-20)
(0.544327 -0.899456 -4.13023e-21)
(0.738355 -0.805219 -1.93844e-20)
(0.865157 -0.688445 1.91809e-20)
(0.946395 -0.573011 2.35661e-20)
(0.99836 -0.467694 -2.83689e-21)
(1.03343 -0.375681 -5.30071e-21)
(1.05561 -0.296856 -8.51125e-22)
(1.07299 -0.229477 6.0658e-21)
(1.08287 -0.176005 -1.2971e-21)
(1.09288 -0.126716 -1.38648e-21)
(1.09996 -0.0967052 -2.89385e-22)
(1.10381 -0.0583283 -3.49711e-23)
(1.116 -0.0438272 -4.73201e-23)
(1.11656 -0.020482 2.4414e-22)
(1.12657 0.00502419 -2.00905e-22)
(1.13466 -0.000577871 2.53399e-23)
(1.14625 0.0401868 1.15805e-22)
(1.11612 0.0393169 -1.82818e-23)
(-0.114611 -0.945187 -9.27127e-21)
(0.330443 -1.00994 5.30946e-20)
(0.589659 -0.928035 -1.76927e-20)
(0.767268 -0.812278 -2.55141e-20)
(0.879674 -0.685579 5.53333e-22)
(0.950451 -0.566741 3.17783e-21)
(0.995448 -0.461123 -5.40984e-21)
(1.02585 -0.369918 -6.35667e-21)
(1.04483 -0.292216 7.01357e-21)
(1.0599 -0.226021 -5.58917e-22)
(1.06811 -0.173427 -3.6871e-21)
(1.07689 -0.125182 4.68165e-22)
(1.08306 -0.0955543 -1.33162e-22)
(1.08624 -0.0579346 1.22301e-22)
(1.09843 -0.0438299 1.23153e-23)
(1.09779 -0.020284 -9.68782e-23)
(1.10895 0.00445751 6.76223e-24)
(1.11703 -0.00112952 -2.01843e-22)
(1.12726 0.0409814 -6.91664e-24)
(1.0982 0.0402714 3.18017e-23)
(-0.0375703 -1.04542 2.88258e-20)
(0.398597 -1.07085 1.47168e-20)
(0.639689 -0.953394 -6.02621e-21)
(0.797708 -0.819086 2.13619e-21)
(0.895206 -0.684208 -1.49979e-20)
(0.955472 -0.562247 9.9579e-21)
(0.993437 -0.456048 -9.27667e-21)
(1.01904 -0.365235 9.98423e-21)
(1.03463 -0.288295 -4.83483e-21)
(1.04724 -0.223 -1.20238e-21)
(1.05361 -0.171109 3.67039e-22)
(1.06104 -0.123782 1.12436e-22)
(1.06617 -0.0944675 -1.83684e-22)
(1.06863 -0.0576049 -9.14732e-23)
(1.08067 -0.0438208 -2.29964e-22)
(1.07884 -0.0201255 -6.18501e-23)
(1.09111 0.00381048 2.80568e-22)
(1.09906 -0.00165062 4.19027e-22)
(1.10793 0.0417699 -5.85593e-23)
(1.08015 0.0411772 5.47003e-23)
(0.0558521 -1.1501 -1.21786e-21)
(0.468143 -1.12728 7.03546e-21)
(0.688365 -0.977258 1.38545e-20)
(0.825747 -0.825529 7.01284e-21)
(0.909036 -0.683712 -5.94132e-21)
(0.959655 -0.559111 -1.15064e-21)
(0.991163 -0.452359 9.69252e-21)
(1.01227 -0.361758 -8.57162e-21)
(1.0246 -0.285343 1.33954e-21)
(1.03476 -0.220709 1.66185e-21)
(1.03927 -0.16933 -4.44315e-23)
(1.04531 -0.122753 5.46578e-22)
(1.04932 -0.0936363 -1.21225e-22)
(1.05103 -0.0574752 5.59871e-23)
(1.06278 -0.0438942 1.14338e-22)
(1.05981 -0.020078 -6.39303e-23)
(1.07315 0.0030545 -2.78166e-22)
(1.08083 -0.00214907 -4.40458e-22)
(1.08835 0.0425397 7.72976e-23)
(1.06204 0.0420348 -6.34466e-23)
(0.160714 -1.25412 1.75796e-21)
(0.536808 -1.17633 -2.47805e-21)
(0.734293 -0.997726 1.49411e-20)
(0.850757 -0.830316 -1.39597e-20)
(0.920659 -0.682783 -1.24565e-20)
(0.962535 -0.55612 -1.42768e-20)
(0.988204 -0.448994 3.87264e-21)
(1.00519 -0.358626 1.39777e-21)
(1.01447 -0.282702 -8.48148e-22)
(1.0223 -0.218662 8.13753e-22)
(1.02499 -0.167749 -3.37469e-22)
(1.02965 -0.121863 5.48643e-22)
(1.03253 -0.0929069 -2.61411e-23)
(1.0335 -0.0574438 -7.39768e-23)
(1.04483 -0.0439892 -2.49035e-22)
(1.04078 -0.0201072 2.90316e-22)
(1.05512 0.00221477 -2.88939e-23)
(1.06241 -0.00260945 3.86224e-22)
(1.06859 0.0432865 -3.55275e-22)
(1.04393 0.0428404 4.48509e-23)
(0.274334 -1.35416 -2.69375e-21)
(0.603859 -1.21801 8.42745e-21)
(0.777087 -1.01485 -1.01767e-20)
(0.872981 -0.833889 4.00991e-21)
(0.930302 -0.681663 4.20559e-21)
(0.964215 -0.553378 7.36058e-21)
(0.984536 -0.445955 -1.22345e-21)
(0.997704 -0.355783 -9.50008e-22)
(1.00414 -0.28029 9.67733e-22)
(1.00977 -0.216777 -8.36563e-22)
(1.01072 -0.166288 -1.67097e-22)
(1.01405 -0.121047 -2.39282e-22)
(1.01581 -0.0922302 1.6072e-22)
(1.01607 -0.0574678 -1.0406e-22)
(1.02689 -0.0440772 1.02811e-22)
(1.02183 -0.0201958 3.34688e-22)
(1.0371 0.00131296 1.35631e-22)
(1.04386 -0.00301963 4.88758e-23)
(1.04873 0.0440071 1.40386e-22)
(1.02586 0.0435908 -1.17982e-23)
(0.394607 -1.44751 -1.24608e-21)
(0.669076 -1.25294 5.9995e-21)
(0.816763 -1.02894 -3.20086e-21)
(0.892938 -0.836779 -3.4255e-21)
(0.938431 -0.680679 1.05923e-21)
(0.964996 -0.551089 -3.04201e-21)
(0.980319 -0.443379 1.84415e-24)
(0.989878 -0.353323 -5.23743e-22)
(0.993608 -0.278172 1.37572e-21)
(0.997143 -0.215097 5.81229e-22)
(0.996436 -0.164974 -3.76567e-22)
(0.998512 -0.120317 4.33339e-23)
(0.999173 -0.0916134 4.30598e-23)
(0.998771 -0.0575423 -3.42031e-23)
(1.009 -0.0441548 1.73606e-22)
(1.00304 -0.0203422 -3.02996e-22)
(1.01915 0.000364483 7.4939e-23)
(1.02524 -0.00337224 -2.8986e-22)
(1.02884 0.044697 2.6819e-22)
(1.00788 0.044284 -1.15393e-22)
(0.519766 -1.53199 1.4718e-21)
(0.732619 -1.28197 -2.91181e-21)
(0.853646 -1.04045 4.62897e-21)
(0.911262 -0.839405 -3.24989e-21)
(0.945577 -0.680053 -1.10179e-21)
(0.965231 -0.549348 -7.98495e-22)
(0.975769 -0.441314 -5.27337e-22)
(0.981831 -0.351277 8.09203e-22)
(0.982943 -0.276373 1.4262e-22)
(0.984455 -0.213642 -3.7995e-22)
(0.982162 -0.163823 1.11324e-23)
(0.983041 -0.119683 3.80159e-23)
(0.982643 -0.0910632 -4.63231e-23)
(0.981638 -0.0576641 2.98739e-22)
(0.991192 -0.0442214 -2.71743e-22)
(0.984452 -0.0205453 1.17901e-22)
(1.0013 -0.000616006 7.92901e-23)
(1.00661 -0.00366172 -2.62823e-22)
(1.00901 0.0453514 -2.27043e-22)
(0.990045 0.044918 5.04289e-23)
(0.648333 -1.60602 -8.07293e-21)
(0.794957 -1.30604 -3.88248e-23)
(0.888322 -1.04991 -2.88333e-22)
(0.928619 -0.842115 1.1631e-21)
(0.952262 -0.679957 -1.15734e-21)
(0.965255 -0.54821 -6.39558e-22)
(0.971107 -0.439776 -1.23727e-23)
(0.973709 -0.34965 -8.64532e-22)
(0.972243 -0.274896 1.83716e-22)
(0.971768 -0.212414 1.82798e-22)
(0.967941 -0.162838 -1.68665e-23)
(0.967674 -0.119147 -1.01413e-23)
(0.966253 -0.0905815 4.75457e-23)
(0.9647 -0.0578278 -1.25894e-22)
(0.973524 -0.0442765 2.22867e-23)
(0.966123 -0.0208039 -1.01397e-23)
(0.983611 -0.00161371 -8.86608e-23)
(0.988016 -0.00388558 2.31551e-22)
(0.989283 0.0459633 9.78989e-23)
(0.972402 0.0454912 3.90107e-23)
(0.779081 -1.66861 1.20872e-21)
(0.856817 -1.32601 -1.78991e-22)
(0.921568 -1.0579 -1.62525e-22)
(0.945653 -0.845172 -1.46986e-22)
(0.958957 -0.680519 4.01205e-23)
(0.965361 -0.547711 -2.04896e-22)
(0.966531 -0.438776 1.09867e-22)
(0.965656 -0.348446 4.92937e-23)
(0.961616 -0.273742 6.48393e-23)
(0.959167 -0.211416 -1.06183e-23)
(0.953837 -0.162022 -8.39957e-24)
(0.952458 -0.118709 -7.24226e-24)
(0.950045 -0.09017 5.85523e-24)
(0.947993 -0.058028 -2.31914e-23)
(0.956034 -0.0443209 -9.3924e-27)
(0.948098 -0.0211147 -1.54819e-23)
(0.966114 -0.00261459 -2.23469e-23)
(0.969516 -0.00404101 3.07812e-23)
(0.96974 0.0465294 -4.42818e-23)
(0.954994 0.0460017 -1.603e-23)
)
;
boundaryField
{
inlet
{
type freestream;
freestreamValue uniform (1 0 0);
value uniform (1 0 0);
}
outlet
{
type freestream;
freestreamValue uniform (1 0 0);
value nonuniform List<vector>
40
(
(0.783686 0.0471035 0)
(0.760356 0.046353 0)
(0.735294 0.0451402 0)
(0.708923 0.0433384 0)
(0.681894 0.0407524 0)
(0.65513 0.0371392 0)
(0.629846 0.0322125 0)
(0.607568 0.0256364 0)
(0.590135 0.017041 0)
(0.579808 0.00610772 0)
(0.937863 0.046448 -1.51329e-23)
(0.921046 0.0468286 3.70183e-23)
(0.904579 0.0471424 6.43961e-23)
(0.888496 0.047388 -1.33767e-22)
(0.872825 0.0475649 -6.68983e-24)
(0.857596 0.0476727 4.76407e-23)
(0.842832 0.0477114 -4.16691e-23)
(0.828556 0.0476805 5.64679e-23)
(0.814788 0.0475777 3.32137e-23)
(0.801547 0.047407 -1.48507e-23)
(1.11612 0.0393169 -1.82818e-23)
(1.0982 0.0402714 3.18017e-23)
(1.08015 0.0411772 5.47003e-23)
(1.06204 0.0420348 -6.34466e-23)
(1.04393 0.0428404 4.48509e-23)
(1.02586 0.0435908 -1.17982e-23)
(1.00788 0.044284 -1.15393e-22)
(0.990045 0.044918 5.04289e-23)
(0.972402 0.0454912 3.90107e-23)
(0.954994 0.0460017 -1.603e-23)
(1.50357 0.00345378 0)
(1.48136 0.00961862 0)
(1.44602 0.0146772 0)
(1.4025 0.0191698 0)
(1.3545 0.0233375 0)
(1.30547 0.0271525 0)
(1.25824 0.0305341 0)
(1.2146 0.0334391 0)
(1.17547 0.0358731 0)
(1.14108 0.0378962 0)
)
;
}
top
{
type symmetryPlane;
}
bottom
{
type symmetryPlane;
}
cylinder
{
type rotatingWallVelocity;
origin (0 0 0);
axis (0 0 1);
omega constant -10;
value nonuniform List<vector>
80
(
(0.19816 -4.99213 4.33076e-24)
(0.588591 -4.96114 3.04002e-23)
(0.975394 -4.8997 -8.93124e-25)
(1.3562 -4.80821 1.77911e-23)
(1.72869 -4.68721 -9.5477e-23)
(2.09058 -4.53746 3.29352e-23)
(2.43965 -4.35985 4.05625e-22)
(2.77377 -4.15548 1.40054e-21)
(3.0909 -3.9256 -8.79813e-22)
(3.38909 -3.67161 -8.99035e-22)
(4.99213 -0.19816 -4.33076e-24)
(4.96114 -0.588591 -3.04002e-23)
(4.8997 -0.975394 8.93124e-25)
(4.80821 -1.3562 1.84427e-23)
(4.68721 -1.72869 -2.77228e-22)
(4.53746 -2.09058 -3.29352e-23)
(4.35985 -2.43965 -4.05625e-22)
(4.15548 -2.77377 2.83102e-22)
(3.9256 -3.0909 -1.22366e-21)
(3.67161 -3.38909 8.99035e-22)
(3.67161 3.38909 8.99035e-22)
(3.9256 3.0909 -1.22366e-21)
(4.15548 2.77377 2.83102e-22)
(4.35985 2.43965 -4.05625e-22)
(4.53746 2.09058 -3.29352e-23)
(4.68721 1.72869 -2.77228e-22)
(4.80821 1.3562 1.84427e-23)
(4.8997 0.975394 8.93124e-25)
(4.96114 0.588591 -3.04002e-23)
(4.99213 0.19816 -4.33076e-24)
(0.19816 4.99213 4.33076e-24)
(0.588591 4.96114 3.04002e-23)
(0.975394 4.8997 -8.93124e-25)
(1.3562 4.80821 1.77911e-23)
(1.72869 4.68721 -9.5477e-23)
(2.09058 4.53746 3.29352e-23)
(2.43965 4.35985 4.05625e-22)
(2.77377 4.15548 -2.83102e-22)
(3.0909 3.9256 -8.79813e-22)
(3.38909 3.67161 -8.99035e-22)
(-3.38909 3.67161 -8.99035e-22)
(-3.0909 3.9256 -8.79813e-22)
(-2.77377 4.15548 1.40054e-21)
(-2.43965 4.35985 4.05625e-22)
(-2.09058 4.53746 3.29352e-23)
(-1.72869 4.68721 -9.5477e-23)
(-1.3562 4.80821 1.77911e-23)
(-0.975394 4.8997 -8.93124e-25)
(-0.588591 4.96114 3.04002e-23)
(-0.19816 4.99213 4.33076e-24)
(-3.67161 3.38909 8.99035e-22)
(-3.9256 3.0909 -1.22366e-21)
(-4.15548 2.77377 2.83102e-22)
(-4.35985 2.43965 -4.05625e-22)
(-4.53746 2.09058 -3.29352e-23)
(-4.68721 1.72869 -2.77228e-22)
(-4.80821 1.3562 1.84427e-23)
(-4.8997 0.975394 8.93124e-25)
(-4.96114 0.588591 -3.04002e-23)
(-4.99213 0.19816 -4.33076e-24)
(-4.99213 -0.19816 -4.33076e-24)
(-4.96114 -0.588591 -3.04002e-23)
(-4.8997 -0.975394 8.93124e-25)
(-4.80821 -1.3562 -1.77911e-23)
(-4.68721 -1.72869 -2.77228e-22)
(-4.53746 -2.09058 -3.29352e-23)
(-4.35985 -2.43965 -4.05625e-22)
(-4.15548 -2.77377 2.83102e-22)
(-3.9256 -3.0909 -1.22366e-21)
(-3.67161 -3.38909 8.99035e-22)
(-3.38909 -3.67161 -8.99035e-22)
(-3.0909 -3.9256 -8.79813e-22)
(-2.77377 -4.15548 -2.83102e-22)
(-2.43965 -4.35985 4.05625e-22)
(-2.09058 -4.53746 3.29352e-23)
(-1.72869 -4.68721 -9.5477e-23)
(-1.3562 -4.80821 1.77911e-23)
(-0.975394 -4.8997 -8.93124e-25)
(-0.588591 -4.96114 3.04002e-23)
(-0.19816 -4.99213 4.33076e-24)
)
;
}
frontandback
{
type empty;
}
}
// ************************************************************************* //
| [
"[email protected]"
] | ||
3b651ba1b6e4974cb32180c440fb66e1769805fb | e0654961ba79338e82a0ba03360e97ead4465285 | /include/argot/detail/variadic_chunk.hpp | 24d92d3d1328c7c4c39778d98d3d8d88ddc2c4f1 | [
"BSL-1.0"
] | permissive | blockspacer/argot | 68f0e2a56fb4686989b47d0ad0f6127167ea0a9a | 97349baaf27659c9dc4d67cf8963b2e871eaedae | refs/heads/master | 2022-11-25T02:57:08.808025 | 2020-08-04T21:15:00 | 2020-08-04T21:15:00 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,378 | hpp | /*==============================================================================
Copyright (c) 2019 Matt Calabrese
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
==============================================================================*/
#ifndef ARGOT_DETAIL_VARIADIC_CHUNK_HPP_
#define ARGOT_DETAIL_VARIADIC_CHUNK_HPP_
#include <argot/detail/constexpr_invoke.hpp>
#include <argot/detail/forward.hpp>
#include <argot/detail/variadic_drop.hpp>
#include <argot/detail/variadic_range.hpp>
#include <argot/detail/variadic_take.hpp>
#include <cstddef>
#include <utility>
namespace argot::detail_argot {
template< class CompleteChunkIndices, bool HasIncompleteFinalChunk >
struct variadic_chunk_impl;
template< std::size_t... ChunkIndices >
struct variadic_chunk_impl
< std::index_sequence< ChunkIndices... >
, /*HasIncompleteFinalChunk =*/ false
>
{
template< std::size_t AmountPerChunk
, class Chunker
, class Fun, class... P
>
static constexpr decltype( auto )
run( Chunker const& chunker, Fun&& fun, P&&... args )
{
return argot_detail::constexpr_invoke
( ARGOT_FORWARD( Fun )( fun )
, variadic_drop_impl< ChunkIndices * AmountPerChunk >::run
( ( bind_variadic_take_run< AmountPerChunk > )( chunker )
, ARGOT_FORWARD( P )( args )...
)...
);
}
template< std::size_t AmountPerChunk
, template< class... > class Chunker
, template< class... > class Result
, class... P
>
using apply
= Result
< variadic_sized_range
< AmountPerChunk * ChunkIndices, AmountPerChunk, Chunker, P... >...
>;
};
template< std::size_t... ChunkIndices >
struct variadic_chunk_impl
< std::index_sequence< ChunkIndices... >
, /*HasIncompleteFinalChunk =*/ true
>
{
template< std::size_t AmountPerChunk
, class Chunker
, class Fun, class... P
>
static constexpr decltype( auto )
run( Chunker const& chunker, Fun&& fun, P&&... args )
{
return argot_detail::constexpr_invoke
( ARGOT_FORWARD( Fun )( fun )
, variadic_drop_impl< ChunkIndices * AmountPerChunk >::run
( ( bind_variadic_take_run< AmountPerChunk > )( chunker )
, ARGOT_FORWARD( P )( args )...
)...
, variadic_drop_impl< sizeof...( ChunkIndices ) * AmountPerChunk >
::run( chunker, ARGOT_FORWARD( P )( args )... )
);
}
template< std::size_t AmountPerChunk
, template< class... > class Chunker
, template< class... > class Result
, class... P
>
using apply
= Result
< variadic_sized_range
< AmountPerChunk * ChunkIndices, AmountPerChunk, Chunker, P... >...
, variadic_drop
< AmountPerChunk * sizeof...( ChunkIndices )
, Chunker, P...
>
>;
};
template< std::size_t AmountPerChunk
, template< class... > class Chunker
, template< class... > class Result
, class... P
>
using variadic_chunk
= typename variadic_chunk_impl
< std::make_index_sequence< sizeof...( P ) / AmountPerChunk >
, sizeof...( P ) % AmountPerChunk != 0
>::template apply< AmountPerChunk, Chunker, Result, P... >;
} // namespace (argot::detail_argot)
#endif // ARGOT_DETAIL_VARIADIC_CHUNK_HPP_
| [
"[email protected]"
] | |
cb56c8c11a9914c6ac48d691af2df1344c4e2891 | abc113bf6a1473d3007f72228b27b52ce401daf5 | /headers/BeverageOrder.h | e83b2982dee1b9e5da1dd3359c2f874411805d24 | [] | no_license | saikat-hub/chaiPoint | 36547b47fa555adb194190f48c636c00e32158d5 | ac37b10b39bac50640c0b96ec8d754406b1c91e6 | refs/heads/master | 2022-11-06T10:17:30.399229 | 2020-06-25T23:54:13 | 2020-06-25T23:54:13 | 275,034,998 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,331 | h | /*
Use enum status of order
*/
#include <bits/stdc++.h>
#include "ItemIngredient.h"
//#include "ItemIngredient.h"
//using namespace std;
// class Beverage is used to store the ingredients needed to prepare a beverage
#ifndef BEVERAGE_ORDER_H
#define BEVERAGE_ORDER_H
class Beverage{
private:
int itemCount;
string name;
vector<Item> requiredItems;
public:
Beverage();
Beverage(string beverageName, Item curItem);
string getName();
void setName(string beverageName);
int getItemCount();
void addItem(Item curItem);
vector<Item> getItems();
};
// The Order class, is used to track the beverages asked in this order
class Order{
private:
int orderStatus;
int beverageCount;
vector<Beverage> beverages;
string customerName;
// To complete the order, we also set its status to completed
bool completeOrder();
public:
Order();
// If it has only one beverage, we want to override the constructor to initializing it with the single beverage for convenience
Order(Beverage curBeverage);
Order(string name, Beverage curBeverage);
string getCustomerName();
int getBeverageCount();
void addBeverage(Beverage curBeverage);
vector<Beverage> getBeverages();
};
//Class goes here, full declaration AND implementation
#endif | [
"[email protected]"
] | |
31c301a0aa192aef821ac1fc4277cc849cd51e89 | d93fd392fab8bea4dc3d06a7b94d5ccd13f268ce | /Kiwi-Engine/Kiwi-Engine/Core/IAsset.h | 6f35166a9cc7865992077c04937efe076c87b689 | [] | no_license | nicoawalker/Kiwi-Engine-2016 | c12cc32e9f3d9b704e4862c8b42fe60d47d10abd | 846607a9646af6d3a417c21e5dfb448f5f02f68f | refs/heads/master | 2021-07-25T00:18:59.464524 | 2017-11-06T22:11:18 | 2017-11-06T22:11:18 | 109,655,729 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,464 | h | #ifndef _KIWI_IASSET_H_
#define _KIWI_IASSET_H_
#include "IThreadSafe.h"
#include <string>
#include <mutex>
#include <vector>
namespace Kiwi
{
enum ASSET_LOAD_STATE { UNLOADED = 0, LOADING, LOADED, LOAD_FAILED };
class IAsset :
public IThreadSafe
{
protected:
/*stores the current load state.
all assets are UNLOADED on creation*/
ASSET_LOAD_STATE m_assetLoadState;
//stores the type of asset this is (e.g. Texture, Mesh, etc)
std::wstring m_assetType;
//the (unique) name of the asset
std::wstring m_assetName;
//vector containing the files that this asset uses
std::vector<std::wstring> m_assetFiles;
//id # unique to this asset
unsigned long m_assetID;
//current ID number that will be assigned to the next asset that is created
static int GlobalAssetID;
static std::mutex GlobalAssetIDMutex;
public:
IAsset( std::wstring name, std::wstring assetType );
virtual ~IAsset() = 0;
void AddAssetFile( std::wstring file ) { m_assetFiles.push_back( file ); }
virtual void SetLoadState( ASSET_LOAD_STATE loadState ) { m_assetLoadState = loadState; }
virtual ASSET_LOAD_STATE GetLoadState()const { return m_assetLoadState; }
virtual unsigned long GetAssetID()const { return m_assetID; }
virtual std::wstring GetAssetType()const { return m_assetType; }
virtual std::wstring GetAssetName()const { return m_assetName; }
virtual std::wstring GetAssetFile( unsigned int fileIndex )const;
};
}
#endif | [
"[email protected]"
] | |
3dcf8d9f1d68fee064425ca4b4d87f8033d2db14 | bd486672078aa6542d75787c28ce4f49a1046481 | /src/util.cpp | 5c14009ab74a81802f2666f33e80158746cd587c | [
"MIT"
] | permissive | bitnetfinancial/bitnetrewards | 95a771666ae107257bffb03f743d673126501c1e | 9a294ac3b3da1e8f233b620183889d6b3c6f21df | refs/heads/master | 2021-10-10T03:50:43.311712 | 2019-01-06T20:24:02 | 2019-01-06T20:24:02 | 115,962,373 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 42,640 | cpp | // Copyright (c) 2009-2010 Satoshi Nakamoto
// Copyright (c) 2009-2012 The Bitcoin developers
// Distributed under the MIT/X11 software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
#ifndef WIN32
// for posix_fallocate
#ifdef __linux__
#define _POSIX_C_SOURCE 200112L
#endif
#include <fcntl.h>
#include <sys/stat.h>
#include <sys/resource.h>
#endif
#include "util.h"
#include "sync.h"
#include "version.h"
#include "ui_interface.h"
#include <boost/algorithm/string/join.hpp>
#include <boost/algorithm/string/case_conv.hpp> // for to_lower()
#include <boost/algorithm/string/predicate.hpp> // for startswith() and endswith()
// Work around clang compilation problem in Boost 1.46:
// /usr/include/boost/program_options/detail/config_file.hpp:163:17: error: call to function 'to_internal' that is neither visible in the template definition nor found by argument-dependent lookup
// See also: http://stackoverflow.com/questions/10020179/compilation-fail-in-boost-librairies-program-options
// http://clang.debian.net/status.php?version=3.0&key=CANNOT_FIND_FUNCTION
namespace boost {
namespace program_options {
std::string to_internal(const std::string&);
}
}
#include <boost/program_options/detail/config_file.hpp>
#include <boost/program_options/parsers.hpp>
#include <boost/filesystem.hpp>
#include <boost/filesystem/fstream.hpp>
#include <boost/foreach.hpp>
#include <boost/thread.hpp>
#include <openssl/crypto.h>
#include <openssl/rand.h>
#include <stdarg.h>
#ifdef WIN32
#ifdef _MSC_VER
#pragma warning(disable:4786)
#pragma warning(disable:4804)
#pragma warning(disable:4805)
#pragma warning(disable:4717)
#endif
#ifdef _WIN32_WINNT
#undef _WIN32_WINNT
#endif
#define _WIN32_WINNT 0x0501
#ifdef _WIN32_IE
#undef _WIN32_IE
#endif
#define _WIN32_IE 0x0501
#define WIN32_LEAN_AND_MEAN 1
#ifndef NOMINMAX
#define NOMINMAX
#endif
#include <io.h> /* for _commit */
#include "shlobj.h"
#elif defined(__linux__)
# include <sys/prctl.h>
#endif
using namespace std;
map<string, string> mapArgs;
map<string, vector<string> > mapMultiArgs;
bool fDebug = false;
bool fDebugNet = false;
bool fPrintToConsole = false;
bool fPrintToDebugger = false;
bool fDaemon = false;
bool fServer = false;
bool fCommandLine = false;
string strMiscWarning;
bool fTestNet = false;
bool fBloomFilters = false;
bool fNoListen = false;
bool fLogTimestamps = false;
CMedianFilter<int64> vTimeOffsets(200,0);
volatile bool fReopenDebugLog = false;
bool fCachedPath[2] = {false, false};
// Init OpenSSL library multithreading support
static CCriticalSection** ppmutexOpenSSL;
void locking_callback(int mode, int i, const char* file, int line)
{
if (mode & CRYPTO_LOCK) {
ENTER_CRITICAL_SECTION(*ppmutexOpenSSL[i]);
} else {
LEAVE_CRITICAL_SECTION(*ppmutexOpenSSL[i]);
}
}
LockedPageManager LockedPageManager::instance;
// Init
class CInit
{
public:
CInit()
{
// Init OpenSSL library multithreading support
ppmutexOpenSSL = (CCriticalSection**)OPENSSL_malloc(CRYPTO_num_locks() * sizeof(CCriticalSection*));
for (int i = 0; i < CRYPTO_num_locks(); i++)
ppmutexOpenSSL[i] = new CCriticalSection();
CRYPTO_set_locking_callback(locking_callback);
#ifdef WIN32
// Seed random number generator with screen scrape and other hardware sources
RAND_screen();
#endif
// Seed random number generator with performance counter
RandAddSeed();
}
~CInit()
{
// Shutdown OpenSSL library multithreading support
CRYPTO_set_locking_callback(NULL);
for (int i = 0; i < CRYPTO_num_locks(); i++)
delete ppmutexOpenSSL[i];
OPENSSL_free(ppmutexOpenSSL);
}
}
instance_of_cinit;
void RandAddSeed()
{
// Seed with CPU performance counter
int64 nCounter = GetPerformanceCounter();
RAND_add(&nCounter, sizeof(nCounter), 1.5);
memset(&nCounter, 0, sizeof(nCounter));
}
void RandAddSeedPerfmon()
{
RandAddSeed();
// This can take up to 2 seconds, so only do it every 10 minutes
static int64 nLastPerfmon;
if (GetTime() < nLastPerfmon + 10 * 60)
return;
nLastPerfmon = GetTime();
#ifdef WIN32
// Don't need this on Linux, OpenSSL automatically uses /dev/urandom
// Seed with the entire set of perfmon data
unsigned char pdata[250000];
memset(pdata, 0, sizeof(pdata));
unsigned long nSize = sizeof(pdata);
long ret = RegQueryValueExA(HKEY_PERFORMANCE_DATA, "Global", NULL, NULL, pdata, &nSize);
RegCloseKey(HKEY_PERFORMANCE_DATA);
if (ret == ERROR_SUCCESS)
{
RAND_add(pdata, nSize, nSize/100.0);
OPENSSL_cleanse(pdata, nSize);
printf("RandAddSeed() %lu bytes\n", nSize);
}
#endif
}
uint64 GetRand(uint64 nMax)
{
if (nMax == 0)
return 0;
// The range of the random source must be a multiple of the modulus
// to give every possible output value an equal possibility
uint64 nRange = (std::numeric_limits<uint64>::max() / nMax) * nMax;
uint64 nRand = 0;
do
RAND_bytes((unsigned char*)&nRand, sizeof(nRand));
while (nRand >= nRange);
return (nRand % nMax);
}
int GetRandInt(int nMax)
{
return GetRand(nMax);
}
uint256 GetRandHash()
{
uint256 hash;
RAND_bytes((unsigned char*)&hash, sizeof(hash));
return hash;
}
//
// OutputDebugStringF (aka printf -- there is a #define that we really
// should get rid of one day) has been broken a couple of times now
// by well-meaning people adding mutexes in the most straightforward way.
// It breaks because it may be called by global destructors during shutdown.
// Since the order of destruction of static/global objects is undefined,
// defining a mutex as a global object doesn't work (the mutex gets
// destroyed, and then some later destructor calls OutputDebugStringF,
// maybe indirectly, and you get a core dump at shutdown trying to lock
// the mutex).
static boost::once_flag debugPrintInitFlag = BOOST_ONCE_INIT;
// We use boost::call_once() to make sure these are initialized in
// in a thread-safe manner the first time it is called:
static FILE* fileout = NULL;
static boost::mutex* mutexDebugLog = NULL;
static void DebugPrintInit()
{
assert(fileout == NULL);
assert(mutexDebugLog == NULL);
boost::filesystem::path pathDebug = GetDataDir() / "debug.log";
fileout = fopen(pathDebug.string().c_str(), "a");
if (fileout) setbuf(fileout, NULL); // unbuffered
mutexDebugLog = new boost::mutex();
}
int OutputDebugStringF(const char* pszFormat, ...)
{
int ret = 0; // Returns total number of characters written
if (fPrintToConsole)
{
// print to console
va_list arg_ptr;
va_start(arg_ptr, pszFormat);
ret += vprintf(pszFormat, arg_ptr);
va_end(arg_ptr);
}
else if (!fPrintToDebugger)
{
static bool fStartedNewLine = true;
boost::call_once(&DebugPrintInit, debugPrintInitFlag);
if (fileout == NULL)
return ret;
boost::mutex::scoped_lock scoped_lock(*mutexDebugLog);
// reopen the log file, if requested
if (fReopenDebugLog) {
fReopenDebugLog = false;
boost::filesystem::path pathDebug = GetDataDir() / "debug.log";
if (freopen(pathDebug.string().c_str(),"a",fileout) != NULL)
setbuf(fileout, NULL); // unbuffered
}
// Debug print useful for profiling
if (fLogTimestamps && fStartedNewLine)
ret += fprintf(fileout, "%s ", DateTimeStrFormat("%Y-%m-%d %H:%M:%S", GetTime()).c_str());
if (pszFormat[strlen(pszFormat) - 1] == '\n')
fStartedNewLine = true;
else
fStartedNewLine = false;
va_list arg_ptr;
va_start(arg_ptr, pszFormat);
ret += vfprintf(fileout, pszFormat, arg_ptr);
va_end(arg_ptr);
}
#ifdef WIN32
if (fPrintToDebugger)
{
static CCriticalSection cs_OutputDebugStringF;
// accumulate and output a line at a time
{
LOCK(cs_OutputDebugStringF);
static std::string buffer;
va_list arg_ptr;
va_start(arg_ptr, pszFormat);
buffer += vstrprintf(pszFormat, arg_ptr);
va_end(arg_ptr);
int line_start = 0, line_end;
while((line_end = buffer.find('\n', line_start)) != -1)
{
OutputDebugStringA(buffer.substr(line_start, line_end - line_start).c_str());
line_start = line_end + 1;
ret += line_end-line_start;
}
buffer.erase(0, line_start);
}
}
#endif
return ret;
}
string vstrprintf(const char *format, va_list ap)
{
char buffer[50000];
char* p = buffer;
int limit = sizeof(buffer);
int ret;
loop
{
va_list arg_ptr;
va_copy(arg_ptr, ap);
#ifdef WIN32
ret = _vsnprintf(p, limit, format, arg_ptr);
#else
ret = vsnprintf(p, limit, format, arg_ptr);
#endif
va_end(arg_ptr);
if (ret >= 0 && ret < limit)
break;
if (p != buffer)
delete[] p;
limit *= 2;
p = new char[limit];
if (p == NULL)
throw std::bad_alloc();
}
string str(p, p+ret);
if (p != buffer)
delete[] p;
return str;
}
string real_strprintf(const char *format, int dummy, ...)
{
va_list arg_ptr;
va_start(arg_ptr, dummy);
string str = vstrprintf(format, arg_ptr);
va_end(arg_ptr);
return str;
}
string real_strprintf(const std::string &format, int dummy, ...)
{
va_list arg_ptr;
va_start(arg_ptr, dummy);
string str = vstrprintf(format.c_str(), arg_ptr);
va_end(arg_ptr);
return str;
}
bool error(const char *format, ...)
{
va_list arg_ptr;
va_start(arg_ptr, format);
std::string str = vstrprintf(format, arg_ptr);
va_end(arg_ptr);
printf("ERROR: %s\n", str.c_str());
return false;
}
void ParseString(const string& str, char c, vector<string>& v)
{
if (str.empty())
return;
string::size_type i1 = 0;
string::size_type i2;
loop
{
i2 = str.find(c, i1);
if (i2 == str.npos)
{
v.push_back(str.substr(i1));
return;
}
v.push_back(str.substr(i1, i2-i1));
i1 = i2+1;
}
}
string FormatMoney(int64 n, bool fPlus)
{
// Note: not using straight sprintf here because we do NOT want
// localized number formatting.
int64 n_abs = (n > 0 ? n : -n);
int64 quotient = n_abs/COIN;
int64 remainder = n_abs%COIN;
string str = strprintf("%"PRI64d".%08"PRI64d, quotient, remainder);
// Right-trim excess zeros before the decimal point:
int nTrim = 0;
for (int i = str.size()-1; (str[i] == '0' && isdigit(str[i-2])); --i)
++nTrim;
if (nTrim)
str.erase(str.size()-nTrim, nTrim);
if (n < 0)
str.insert((unsigned int)0, 1, '-');
else if (fPlus && n > 0)
str.insert((unsigned int)0, 1, '+');
return str;
}
bool ParseMoney(const string& str, int64& nRet)
{
return ParseMoney(str.c_str(), nRet);
}
bool ParseMoney(const char* pszIn, int64& nRet)
{
string strWhole;
int64 nUnits = 0;
const char* p = pszIn;
while (isspace(*p))
p++;
for (; *p; p++)
{
if (*p == '.')
{
p++;
int64 nMult = CENT*10;
while (isdigit(*p) && (nMult > 0))
{
nUnits += nMult * (*p++ - '0');
nMult /= 10;
}
break;
}
if (isspace(*p))
break;
if (!isdigit(*p))
return false;
strWhole.insert(strWhole.end(), *p);
}
for (; *p; p++)
if (!isspace(*p))
return false;
if (strWhole.size() > 10) // guard against 63 bit overflow
return false;
if (nUnits < 0 || nUnits > COIN)
return false;
int64 nWhole = atoi64(strWhole);
int64 nValue = nWhole*COIN + nUnits;
nRet = nValue;
return true;
}
static const signed char phexdigit[256] =
{ -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
0,1,2,3,4,5,6,7,8,9,-1,-1,-1,-1,-1,-1,
-1,0xa,0xb,0xc,0xd,0xe,0xf,-1,-1,-1,-1,-1,-1,-1,-1,-1,
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
-1,0xa,0xb,0xc,0xd,0xe,0xf,-1,-1,-1,-1,-1,-1,-1,-1,-1,
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, };
bool IsHex(const string& str)
{
BOOST_FOREACH(unsigned char c, str)
{
if (phexdigit[c] < 0)
return false;
}
return (str.size() > 0) && (str.size()%2 == 0);
}
vector<unsigned char> ParseHex(const char* psz)
{
// convert hex dump to vector
vector<unsigned char> vch;
loop
{
while (isspace(*psz))
psz++;
signed char c = phexdigit[(unsigned char)*psz++];
if (c == (signed char)-1)
break;
unsigned char n = (c << 4);
c = phexdigit[(unsigned char)*psz++];
if (c == (signed char)-1)
break;
n |= c;
vch.push_back(n);
}
return vch;
}
vector<unsigned char> ParseHex(const string& str)
{
return ParseHex(str.c_str());
}
static void InterpretNegativeSetting(string name, map<string, string>& mapSettingsRet)
{
// interpret -nofoo as -foo=0 (and -nofoo=0 as -foo=1) as long as -foo not set
if (name.find("-no") == 0)
{
std::string positive("-");
positive.append(name.begin()+3, name.end());
if (mapSettingsRet.count(positive) == 0)
{
bool value = !GetBoolArg(name);
mapSettingsRet[positive] = (value ? "1" : "0");
}
}
}
void ParseParameters(int argc, const char* const argv[])
{
mapArgs.clear();
mapMultiArgs.clear();
for (int i = 1; i < argc; i++)
{
std::string str(argv[i]);
std::string strValue;
size_t is_index = str.find('=');
if (is_index != std::string::npos)
{
strValue = str.substr(is_index+1);
str = str.substr(0, is_index);
}
#ifdef WIN32
boost::to_lower(str);
if (boost::algorithm::starts_with(str, "/"))
str = "-" + str.substr(1);
#endif
if (str[0] != '-')
break;
mapArgs[str] = strValue;
mapMultiArgs[str].push_back(strValue);
}
// New 0.6 features:
BOOST_FOREACH(const PAIRTYPE(string,string)& entry, mapArgs)
{
string name = entry.first;
// interpret --foo as -foo (as long as both are not set)
if (name.find("--") == 0)
{
std::string singleDash(name.begin()+1, name.end());
if (mapArgs.count(singleDash) == 0)
mapArgs[singleDash] = entry.second;
name = singleDash;
}
// interpret -nofoo as -foo=0 (and -nofoo=0 as -foo=1) as long as -foo not set
InterpretNegativeSetting(name, mapArgs);
}
}
std::string GetArg(const std::string& strArg, const std::string& strDefault)
{
if (mapArgs.count(strArg))
return mapArgs[strArg];
return strDefault;
}
int64 GetArg(const std::string& strArg, int64 nDefault)
{
if (mapArgs.count(strArg))
return atoi64(mapArgs[strArg]);
return nDefault;
}
bool GetBoolArg(const std::string& strArg, bool fDefault)
{
if (mapArgs.count(strArg))
{
if (mapArgs[strArg].empty())
return true;
return (atoi(mapArgs[strArg]) != 0);
}
return fDefault;
}
bool SoftSetArg(const std::string& strArg, const std::string& strValue)
{
if (mapArgs.count(strArg))
return false;
mapArgs[strArg] = strValue;
return true;
}
bool SoftSetBoolArg(const std::string& strArg, bool fValue)
{
if (fValue)
return SoftSetArg(strArg, std::string("1"));
else
return SoftSetArg(strArg, std::string("0"));
}
string EncodeBase64(const unsigned char* pch, size_t len)
{
static const char *pbase64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
string strRet="";
strRet.reserve((len+2)/3*4);
int mode=0, left=0;
const unsigned char *pchEnd = pch+len;
while (pch<pchEnd)
{
int enc = *(pch++);
switch (mode)
{
case 0: // we have no bits
strRet += pbase64[enc >> 2];
left = (enc & 3) << 4;
mode = 1;
break;
case 1: // we have two bits
strRet += pbase64[left | (enc >> 4)];
left = (enc & 15) << 2;
mode = 2;
break;
case 2: // we have four bits
strRet += pbase64[left | (enc >> 6)];
strRet += pbase64[enc & 63];
mode = 0;
break;
}
}
if (mode)
{
strRet += pbase64[left];
strRet += '=';
if (mode == 1)
strRet += '=';
}
return strRet;
}
string EncodeBase64(const string& str)
{
return EncodeBase64((const unsigned char*)str.c_str(), str.size());
}
vector<unsigned char> DecodeBase64(const char* p, bool* pfInvalid)
{
static const int decode64_table[256] =
{
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, 62, -1, -1, -1, 63, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, -1, -1,
-1, -1, -1, -1, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -1, -1, -1, -1, -1, -1, 26, 27, 28,
29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48,
49, 50, 51, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1
};
if (pfInvalid)
*pfInvalid = false;
vector<unsigned char> vchRet;
vchRet.reserve(strlen(p)*3/4);
int mode = 0;
int left = 0;
while (1)
{
int dec = decode64_table[(unsigned char)*p];
if (dec == -1) break;
p++;
switch (mode)
{
case 0: // we have no bits and get 6
left = dec;
mode = 1;
break;
case 1: // we have 6 bits and keep 4
vchRet.push_back((left<<2) | (dec>>4));
left = dec & 15;
mode = 2;
break;
case 2: // we have 4 bits and get 6, we keep 2
vchRet.push_back((left<<4) | (dec>>2));
left = dec & 3;
mode = 3;
break;
case 3: // we have 2 bits and get 6
vchRet.push_back((left<<6) | dec);
mode = 0;
break;
}
}
if (pfInvalid)
switch (mode)
{
case 0: // 4n base64 characters processed: ok
break;
case 1: // 4n+1 base64 character processed: impossible
*pfInvalid = true;
break;
case 2: // 4n+2 base64 characters processed: require '=='
if (left || p[0] != '=' || p[1] != '=' || decode64_table[(unsigned char)p[2]] != -1)
*pfInvalid = true;
break;
case 3: // 4n+3 base64 characters processed: require '='
if (left || p[0] != '=' || decode64_table[(unsigned char)p[1]] != -1)
*pfInvalid = true;
break;
}
return vchRet;
}
string DecodeBase64(const string& str)
{
vector<unsigned char> vchRet = DecodeBase64(str.c_str());
return string((const char*)&vchRet[0], vchRet.size());
}
string EncodeBase32(const unsigned char* pch, size_t len)
{
static const char *pbase32 = "abcdefghijklmnopqrstuvwxyz234567";
string strRet="";
strRet.reserve((len+4)/5*8);
int mode=0, left=0;
const unsigned char *pchEnd = pch+len;
while (pch<pchEnd)
{
int enc = *(pch++);
switch (mode)
{
case 0: // we have no bits
strRet += pbase32[enc >> 3];
left = (enc & 7) << 2;
mode = 1;
break;
case 1: // we have three bits
strRet += pbase32[left | (enc >> 6)];
strRet += pbase32[(enc >> 1) & 31];
left = (enc & 1) << 4;
mode = 2;
break;
case 2: // we have one bit
strRet += pbase32[left | (enc >> 4)];
left = (enc & 15) << 1;
mode = 3;
break;
case 3: // we have four bits
strRet += pbase32[left | (enc >> 7)];
strRet += pbase32[(enc >> 2) & 31];
left = (enc & 3) << 3;
mode = 4;
break;
case 4: // we have two bits
strRet += pbase32[left | (enc >> 5)];
strRet += pbase32[enc & 31];
mode = 0;
}
}
static const int nPadding[5] = {0, 6, 4, 3, 1};
if (mode)
{
strRet += pbase32[left];
for (int n=0; n<nPadding[mode]; n++)
strRet += '=';
}
return strRet;
}
string EncodeBase32(const string& str)
{
return EncodeBase32((const unsigned char*)str.c_str(), str.size());
}
vector<unsigned char> DecodeBase32(const char* p, bool* pfInvalid)
{
static const int decode32_table[256] =
{
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 26, 27, 28, 29, 30, 31, -1, -1, -1, -1,
-1, -1, -1, -1, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -1, -1, -1, -1, -1, -1, 0, 1, 2,
3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22,
23, 24, 25, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1
};
if (pfInvalid)
*pfInvalid = false;
vector<unsigned char> vchRet;
vchRet.reserve((strlen(p))*5/8);
int mode = 0;
int left = 0;
while (1)
{
int dec = decode32_table[(unsigned char)*p];
if (dec == -1) break;
p++;
switch (mode)
{
case 0: // we have no bits and get 5
left = dec;
mode = 1;
break;
case 1: // we have 5 bits and keep 2
vchRet.push_back((left<<3) | (dec>>2));
left = dec & 3;
mode = 2;
break;
case 2: // we have 2 bits and keep 7
left = left << 5 | dec;
mode = 3;
break;
case 3: // we have 7 bits and keep 4
vchRet.push_back((left<<1) | (dec>>4));
left = dec & 15;
mode = 4;
break;
case 4: // we have 4 bits, and keep 1
vchRet.push_back((left<<4) | (dec>>1));
left = dec & 1;
mode = 5;
break;
case 5: // we have 1 bit, and keep 6
left = left << 5 | dec;
mode = 6;
break;
case 6: // we have 6 bits, and keep 3
vchRet.push_back((left<<2) | (dec>>3));
left = dec & 7;
mode = 7;
break;
case 7: // we have 3 bits, and keep 0
vchRet.push_back((left<<5) | dec);
mode = 0;
break;
}
}
if (pfInvalid)
switch (mode)
{
case 0: // 8n base32 characters processed: ok
break;
case 1: // 8n+1 base32 characters processed: impossible
case 3: // +3
case 6: // +6
*pfInvalid = true;
break;
case 2: // 8n+2 base32 characters processed: require '======'
if (left || p[0] != '=' || p[1] != '=' || p[2] != '=' || p[3] != '=' || p[4] != '=' || p[5] != '=' || decode32_table[(unsigned char)p[6]] != -1)
*pfInvalid = true;
break;
case 4: // 8n+4 base32 characters processed: require '===='
if (left || p[0] != '=' || p[1] != '=' || p[2] != '=' || p[3] != '=' || decode32_table[(unsigned char)p[4]] != -1)
*pfInvalid = true;
break;
case 5: // 8n+5 base32 characters processed: require '==='
if (left || p[0] != '=' || p[1] != '=' || p[2] != '=' || decode32_table[(unsigned char)p[3]] != -1)
*pfInvalid = true;
break;
case 7: // 8n+7 base32 characters processed: require '='
if (left || p[0] != '=' || decode32_table[(unsigned char)p[1]] != -1)
*pfInvalid = true;
break;
}
return vchRet;
}
string DecodeBase32(const string& str)
{
vector<unsigned char> vchRet = DecodeBase32(str.c_str());
return string((const char*)&vchRet[0], vchRet.size());
}
bool WildcardMatch(const char* psz, const char* mask)
{
loop
{
switch (*mask)
{
case '\0':
return (*psz == '\0');
case '*':
return WildcardMatch(psz, mask+1) || (*psz && WildcardMatch(psz+1, mask));
case '?':
if (*psz == '\0')
return false;
break;
default:
if (*psz != *mask)
return false;
break;
}
psz++;
mask++;
}
}
bool WildcardMatch(const string& str, const string& mask)
{
return WildcardMatch(str.c_str(), mask.c_str());
}
static std::string FormatException(std::exception* pex, const char* pszThread)
{
#ifdef WIN32
char pszModule[MAX_PATH] = "";
GetModuleFileNameA(NULL, pszModule, sizeof(pszModule));
#else
const char* pszModule = "bitnetrewards";
#endif
if (pex)
return strprintf(
"EXCEPTION: %s \n%s \n%s in %s \n", typeid(*pex).name(), pex->what(), pszModule, pszThread);
else
return strprintf(
"UNKNOWN EXCEPTION \n%s in %s \n", pszModule, pszThread);
}
void LogException(std::exception* pex, const char* pszThread)
{
std::string message = FormatException(pex, pszThread);
printf("\n%s", message.c_str());
}
void PrintException(std::exception* pex, const char* pszThread)
{
std::string message = FormatException(pex, pszThread);
printf("\n\n************************\n%s\n", message.c_str());
fprintf(stderr, "\n\n************************\n%s\n", message.c_str());
strMiscWarning = message;
throw;
}
void PrintExceptionContinue(std::exception* pex, const char* pszThread)
{
std::string message = FormatException(pex, pszThread);
printf("\n\n************************\n%s\n", message.c_str());
fprintf(stderr, "\n\n************************\n%s\n", message.c_str());
strMiscWarning = message;
}
boost::filesystem::path GetDefaultDataDir()
{
namespace fs = boost::filesystem;
// Windows < Vista: C:\Documents and Settings\Username\Application Data\Bitcoin
// Windows >= Vista: C:\Users\Username\AppData\Roaming\Bitcoin
// Mac: ~/Library/Application Support/Bitcoin
// Unix: ~/.bitcoin
#ifdef WIN32
// Windows
return GetSpecialFolderPath(CSIDL_APPDATA) / "bitnetrewards";
#else
fs::path pathRet;
char* pszHome = getenv("HOME");
if (pszHome == NULL || strlen(pszHome) == 0)
pathRet = fs::path("/");
else
pathRet = fs::path(pszHome);
#ifdef MAC_OSX
// Mac
pathRet /= "Library/Application Support";
fs::create_directory(pathRet);
return pathRet / "bitnetrewards";
#else
// Unix
return pathRet / ".bitnetrewards";
#endif
#endif
}
const boost::filesystem::path &GetDataDir(bool fNetSpecific)
{
namespace fs = boost::filesystem;
static fs::path pathCached[2];
static CCriticalSection csPathCached;
fs::path &path = pathCached[fNetSpecific];
// This can be called during exceptions by printf, so we cache the
// value so we don't have to do memory allocations after that.
if (fCachedPath[fNetSpecific])
return path;
LOCK(csPathCached);
if (mapArgs.count("-datadir")) {
path = fs::system_complete(mapArgs["-datadir"]);
if (!fs::is_directory(path)) {
path = "";
return path;
}
} else {
path = GetDefaultDataDir();
}
if (fNetSpecific && GetBoolArg("-testnet", false))
path /= "testnet3";
fs::create_directory(path);
fCachedPath[fNetSpecific] = true;
return path;
}
boost::filesystem::path GetConfigFile()
{
boost::filesystem::path pathConfigFile(GetArg("-conf", "bitnetrewards.conf"));
if (!pathConfigFile.is_complete()) pathConfigFile = GetDataDir(false) / pathConfigFile;
return pathConfigFile;
}
void ReadConfigFile(map<string, string>& mapSettingsRet,
map<string, vector<string> >& mapMultiSettingsRet)
{
boost::filesystem::ifstream streamConfig(GetConfigFile());
if (!streamConfig.good())
return; // No bitcoin.conf file is OK
// clear path cache after loading config file
fCachedPath[0] = fCachedPath[1] = false;
set<string> setOptions;
setOptions.insert("*");
for (boost::program_options::detail::config_file_iterator it(streamConfig, setOptions), end; it != end; ++it)
{
// Don't overwrite existing settings so command line settings override bitcoin.conf
string strKey = string("-") + it->string_key;
if (mapSettingsRet.count(strKey) == 0)
{
mapSettingsRet[strKey] = it->value[0];
// interpret nofoo=1 as foo=0 (and nofoo=0 as foo=1) as long as foo not set)
InterpretNegativeSetting(strKey, mapSettingsRet);
}
mapMultiSettingsRet[strKey].push_back(it->value[0]);
}
}
boost::filesystem::path GetPidFile()
{
boost::filesystem::path pathPidFile(GetArg("-pid", "bitnetrewardsd.pid"));
if (!pathPidFile.is_complete()) pathPidFile = GetDataDir() / pathPidFile;
return pathPidFile;
}
void CreatePidFile(const boost::filesystem::path &path, pid_t pid)
{
FILE* file = fopen(path.string().c_str(), "w");
if (file)
{
fprintf(file, "%d\n", pid);
fclose(file);
}
}
bool RenameOver(boost::filesystem::path src, boost::filesystem::path dest)
{
#ifdef WIN32
return MoveFileExA(src.string().c_str(), dest.string().c_str(),
MOVEFILE_REPLACE_EXISTING);
#else
int rc = std::rename(src.string().c_str(), dest.string().c_str());
return (rc == 0);
#endif /* WIN32 */
}
void FileCommit(FILE *fileout)
{
fflush(fileout); // harmless if redundantly called
#ifdef WIN32
_commit(_fileno(fileout));
#else
#if defined(__linux__) || defined(__NetBSD__)
fdatasync(fileno(fileout));
#else
fsync(fileno(fileout));
#endif
#endif
}
int GetFilesize(FILE* file)
{
int nSavePos = ftell(file);
int nFilesize = -1;
if (fseek(file, 0, SEEK_END) == 0)
nFilesize = ftell(file);
fseek(file, nSavePos, SEEK_SET);
return nFilesize;
}
bool TruncateFile(FILE *file, unsigned int length) {
#if defined(WIN32)
return _chsize(_fileno(file), length) == 0;
#else
return ftruncate(fileno(file), length) == 0;
#endif
}
// this function tries to raise the file descriptor limit to the requested number.
// It returns the actual file descriptor limit (which may be more or less than nMinFD)
int RaiseFileDescriptorLimit(int nMinFD) {
#if defined(WIN32)
return 2048;
#else
struct rlimit limitFD;
if (getrlimit(RLIMIT_NOFILE, &limitFD) != -1) {
if (limitFD.rlim_cur < (rlim_t)nMinFD) {
limitFD.rlim_cur = nMinFD;
if (limitFD.rlim_cur > limitFD.rlim_max)
limitFD.rlim_cur = limitFD.rlim_max;
setrlimit(RLIMIT_NOFILE, &limitFD);
getrlimit(RLIMIT_NOFILE, &limitFD);
}
return limitFD.rlim_cur;
}
return nMinFD; // getrlimit failed, assume it's fine
#endif
}
// this function tries to make a particular range of a file allocated (corresponding to disk space)
// it is advisory, and the range specified in the arguments will never contain live data
void AllocateFileRange(FILE *file, unsigned int offset, unsigned int length) {
#if defined(WIN32)
// Windows-specific version
HANDLE hFile = (HANDLE)_get_osfhandle(_fileno(file));
LARGE_INTEGER nFileSize;
int64 nEndPos = (int64)offset + length;
nFileSize.u.LowPart = nEndPos & 0xFFFFFFFF;
nFileSize.u.HighPart = nEndPos >> 32;
SetFilePointerEx(hFile, nFileSize, 0, FILE_BEGIN);
SetEndOfFile(hFile);
#elif defined(MAC_OSX)
// OSX specific version
fstore_t fst;
fst.fst_flags = F_ALLOCATECONTIG;
fst.fst_posmode = F_PEOFPOSMODE;
fst.fst_offset = 0;
fst.fst_length = (off_t)offset + length;
fst.fst_bytesalloc = 0;
if (fcntl(fileno(file), F_PREALLOCATE, &fst) == -1) {
fst.fst_flags = F_ALLOCATEALL;
fcntl(fileno(file), F_PREALLOCATE, &fst);
}
ftruncate(fileno(file), fst.fst_length);
#elif defined(__linux__)
// Version using posix_fallocate
off_t nEndPos = (off_t)offset + length;
posix_fallocate(fileno(file), 0, nEndPos);
#else
// Fallback version
// TODO: just write one byte per block
static const char buf[65536] = {};
fseek(file, offset, SEEK_SET);
while (length > 0) {
unsigned int now = 65536;
if (length < now)
now = length;
fwrite(buf, 1, now, file); // allowed to fail; this function is advisory anyway
length -= now;
}
#endif
}
void ShrinkDebugFile()
{
// Scroll debug.log if it's getting too big
boost::filesystem::path pathLog = GetDataDir() / "debug.log";
FILE* file = fopen(pathLog.string().c_str(), "r");
if (file && GetFilesize(file) > 10 * 1000000)
{
// Restart the file with some of the end
char pch[200000];
fseek(file, -sizeof(pch), SEEK_END);
int nBytes = fread(pch, 1, sizeof(pch), file);
fclose(file);
file = fopen(pathLog.string().c_str(), "w");
if (file)
{
fwrite(pch, 1, nBytes, file);
fclose(file);
}
}
else if(file != NULL)
fclose(file);
}
//
// "Never go to sea with two chronometers; take one or three."
// Our three time sources are:
// - System clock
// - Median of other nodes clocks
// - The user (asking the user to fix the system clock if the first two disagree)
//
static int64 nMockTime = 0; // For unit testing
int64 GetTime()
{
if (nMockTime) return nMockTime;
return time(NULL);
}
void SetMockTime(int64 nMockTimeIn)
{
nMockTime = nMockTimeIn;
}
static int64 nTimeOffset = 0;
int64 GetTimeOffset()
{
return nTimeOffset;
}
int64 GetAdjustedTime()
{
return GetTime() + GetTimeOffset();
}
void AddTimeData(const CNetAddr& ip, int64 nTime)
{
int64 nOffsetSample = nTime - GetTime();
// Ignore duplicates
static set<CNetAddr> setKnown;
if (!setKnown.insert(ip).second)
return;
// Add data
vTimeOffsets.input(nOffsetSample);
printf("Added time data, samples %d, offset %+"PRI64d" (%+"PRI64d" minutes)\n", vTimeOffsets.size(), nOffsetSample, nOffsetSample/60);
if (vTimeOffsets.size() >= 5 && vTimeOffsets.size() % 2 == 1)
{
int64 nMedian = vTimeOffsets.median();
std::vector<int64> vSorted = vTimeOffsets.sorted();
// Only let other nodes change our time by so much
if (abs64(nMedian) < 35 * 60) // bitnetrewards: changed maximum adjust to 35 mins to avoid letting peers change our time too much in case of an attack.
{
nTimeOffset = nMedian;
}
else
{
nTimeOffset = 0;
static bool fDone;
if (!fDone)
{
// If nobody has a time different than ours but within 5 minutes of ours, give a warning
bool fMatch = false;
BOOST_FOREACH(int64 nOffset, vSorted)
if (nOffset != 0 && abs64(nOffset) < 5 * 60)
fMatch = true;
if (!fMatch)
{
fDone = true;
string strMessage = _("Warning: Please check that your computer's date and time are correct! If your clock is wrong bitnetrewards will not work properly.");
strMiscWarning = strMessage;
printf("*** %s\n", strMessage.c_str());
uiInterface.ThreadSafeMessageBox(strMessage, "", CClientUIInterface::MSG_WARNING);
}
}
}
if (fDebug) {
BOOST_FOREACH(int64 n, vSorted)
printf("%+"PRI64d" ", n);
printf("| ");
}
printf("nTimeOffset = %+"PRI64d" (%+"PRI64d" minutes)\n", nTimeOffset, nTimeOffset/60);
}
}
uint32_t insecure_rand_Rz = 11;
uint32_t insecure_rand_Rw = 11;
void seed_insecure_rand(bool fDeterministic)
{
//The seed values have some unlikely fixed points which we avoid.
if(fDeterministic)
{
insecure_rand_Rz = insecure_rand_Rw = 11;
} else {
uint32_t tmp;
do {
RAND_bytes((unsigned char*)&tmp, 4);
} while(tmp == 0 || tmp == 0x9068ffffU);
insecure_rand_Rz = tmp;
do {
RAND_bytes((unsigned char*)&tmp, 4);
} while(tmp == 0 || tmp == 0x464fffffU);
insecure_rand_Rw = tmp;
}
}
string FormatVersion(int nVersion)
{
if (nVersion%100 == 0)
return strprintf("%d.%d.%d", nVersion/1000000, (nVersion/10000)%100, (nVersion/100)%100);
else
return strprintf("%d.%d.%d.%d", nVersion/1000000, (nVersion/10000)%100, (nVersion/100)%100, nVersion%100);
}
string FormatFullVersion()
{
return CLIENT_BUILD;
}
// Format the subversion field according to BIP 14 spec (https://en.bitcoin.it/wiki/BIP_0014)
std::string FormatSubVersion(const std::string& name, int nClientVersion, const std::vector<std::string>& comments)
{
std::ostringstream ss;
ss << "/";
ss << name << ":" << FormatVersion(nClientVersion);
if (!comments.empty())
ss << "(" << boost::algorithm::join(comments, "; ") << ")";
ss << "/";
return ss.str();
}
#ifdef WIN32
boost::filesystem::path GetSpecialFolderPath(int nFolder, bool fCreate)
{
namespace fs = boost::filesystem;
char pszPath[MAX_PATH] = "";
if(SHGetSpecialFolderPathA(NULL, pszPath, nFolder, fCreate))
{
return fs::path(pszPath);
}
printf("SHGetSpecialFolderPathA() failed, could not obtain requested path.\n");
return fs::path("");
}
#endif
boost::filesystem::path GetTempPath() {
#if BOOST_FILESYSTEM_VERSION == 3
return boost::filesystem::temp_directory_path();
#else
// TODO: remove when we don't support filesystem v2 anymore
boost::filesystem::path path;
#ifdef WIN32
char pszPath[MAX_PATH] = "";
if (GetTempPathA(MAX_PATH, pszPath))
path = boost::filesystem::path(pszPath);
#else
path = boost::filesystem::path("/tmp");
#endif
if (path.empty() || !boost::filesystem::is_directory(path)) {
printf("GetTempPath(): failed to find temp path\n");
return boost::filesystem::path("");
}
return path;
#endif
}
void runCommand(std::string strCommand)
{
int nErr = ::system(strCommand.c_str());
if (nErr)
printf("runCommand error: system(%s) returned %d\n", strCommand.c_str(), nErr);
}
void RenameThread(const char* name)
{
#if defined(PR_SET_NAME)
// Only the first 15 characters are used (16 - NUL terminator)
::prctl(PR_SET_NAME, name, 0, 0, 0);
#elif 0 && (defined(__FreeBSD__) || defined(__OpenBSD__))
// TODO: This is currently disabled because it needs to be verified to work
// on FreeBSD or OpenBSD first. When verified the '0 &&' part can be
// removed.
pthread_set_name_np(pthread_self(), name);
#elif defined(MAC_OSX) && defined(__MAC_OS_X_VERSION_MAX_ALLOWED)
// pthread_setname_np is XCode 10.6-and-later
#if __MAC_OS_X_VERSION_MAX_ALLOWED >= 1060
pthread_setname_np(name);
#endif
#else
// Prevent warnings for unused parameters...
(void)name;
#endif
}
bool NewThread(void(*pfn)(void*), void* parg)
{
try
{
boost::thread(pfn, parg); // thread detaches when out of scope
} catch(boost::thread_resource_error &e) {
printf("Error creating thread: %s\n", e.what());
return false;
}
return true;
}
| [
"[email protected]"
] | |
3e4fc4e6a45350ac5089b0efbf7ba9d9148fbe08 | 2e361df6cbb79d419fb8990f9ecbac8098851cf4 | /3dparty/djvu/DjVuDocument.h | ca08923eeea7573c50f0c51ea651f6c81e90e4c6 | [] | no_license | anubhavrohatgi/nsrreadercore | f499be1759a365829d1a9a107eb8c8c4355618af | a40213300db50b8a5eabe4a301e640e89d1d698e | refs/heads/master | 2020-06-13T01:49:20.388261 | 2015-10-13T22:32:19 | 2015-10-13T22:32:19 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 44,743 | h | //C- -*- C++ -*-
//C- -------------------------------------------------------------------
//C- DjVuLibre-3.5
//C- Copyright (c) 2002 Leon Bottou and Yann Le Cun.
//C- Copyright (c) 2001 AT&T
//C-
//C- This software is subject to, and may be distributed under, the
//C- GNU General Public License, either Version 2 of the license,
//C- or (at your option) any later version. The license should have
//C- accompanied the software or you may obtain a copy of the license
//C- from the Free Software Foundation at http://www.fsf.org .
//C-
//C- This program is distributed in the hope that it will be useful,
//C- but WITHOUT ANY WARRANTY; without even the implied warranty of
//C- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
//C- GNU General Public License for more details.
//C-
//C- DjVuLibre-3.5 is derived from the DjVu(r) Reference Library from
//C- Lizardtech Software. Lizardtech Software has authorized us to
//C- replace the original DjVu(r) Reference Library notice by the following
//C- text (see doc/lizard2002.djvu and doc/lizardtech2007.djvu):
//C-
//C- ------------------------------------------------------------------
//C- | DjVu (r) Reference Library (v. 3.5)
//C- | Copyright (c) 1999-2001 LizardTech, Inc. All Rights Reserved.
//C- | The DjVu Reference Library is protected by U.S. Pat. No.
//C- | 6,058,214 and patents pending.
//C- |
//C- | This software is subject to, and may be distributed under, the
//C- | GNU General Public License, either Version 2 of the license,
//C- | or (at your option) any later version. The license should have
//C- | accompanied the software or you may obtain a copy of the license
//C- | from the Free Software Foundation at http://www.fsf.org .
//C- |
//C- | The computer code originally released by LizardTech under this
//C- | license and unmodified by other parties is deemed "the LIZARDTECH
//C- | ORIGINAL CODE." Subject to any third party intellectual property
//C- | claims, LizardTech grants recipient a worldwide, royalty-free,
//C- | non-exclusive license to make, use, sell, or otherwise dispose of
//C- | the LIZARDTECH ORIGINAL CODE or of programs derived from the
//C- | LIZARDTECH ORIGINAL CODE in compliance with the terms of the GNU
//C- | General Public License. This grant only confers the right to
//C- | infringe patent claims underlying the LIZARDTECH ORIGINAL CODE to
//C- | the extent such infringement is reasonably necessary to enable
//C- | recipient to make, have made, practice, sell, or otherwise dispose
//C- | of the LIZARDTECH ORIGINAL CODE (or portions thereof) and not to
//C- | any greater extent that may be necessary to utilize further
//C- | modifications or combinations.
//C- |
//C- | The LIZARDTECH ORIGINAL CODE is provided "AS IS" WITHOUT WARRANTY
//C- | OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
//C- | TO ANY WARRANTY OF NON-INFRINGEMENT, OR ANY IMPLIED WARRANTY OF
//C- | MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
//C- +------------------------------------------------------------------
#ifndef _DJVUDOCUMENT_H
#define _DJVUDOCUMENT_H
#ifdef HAVE_CONFIG_H
#include "config-djvu.h"
#endif
#if NEED_GNUG_PRAGMAS
# pragma interface
#endif
#include "DjVuPort.h"
#ifdef HAVE_NAMESPACES
namespace DJVU {
# ifdef NOT_DEFINED // Just to fool emacs c++ mode
}
#endif
#endif
class DjVmDoc;
class DjVmDir;
class DjVmDir0;
class DjVmNav;
class DjVuImage;
class DjVuFile;
class DjVuFileCache;
class DjVuNavDir;
class ByteStream;
/** @name DjVuDocument.h
Files #"DjVuDocument.h"# and #"DjVuDocument.cpp"# contain implementation
of the \Ref{DjVuDocument} class - the ideal tool for opening, decoding
and saving DjVu single page and multi page documents.
@memo DjVu document class.
@author Andrei Erofeev <[email protected]>
*/
//@{
/** #DjVuDocument# provides convenient interface for opening, decoding
and saving back DjVu documents in single page and multi page formats.
{\bf Input formats}
It can read multi page DjVu documents in either of the 4 formats: 2
obsolete ({\em old bundled} and {\em old indexed}) and two new
({\em new bundled} and {\em new indirect}).
{\bf Output formats}
To encourage users to switch to the new formats, the #DjVuDocument# can
save documents back only in the new formats: {\em bundled} and
{\em indirect}.
{\bf Conversion.} Since #DjVuDocument# can open DjVu documents in
an obsolete format and save it in any of the two new formats
({\em new bundled} and {\em new indirect}), this class can be used for
conversion from obsolete formats to the new ones. Although it can also
do conversion between the new two formats, it's not the best way to
do it. Please refer to \Ref{DjVmDoc} for details.
{\bf Decoding.} #DjVuDocument# provides convenient interface for obtaining
\Ref{DjVuImage} corresponding to any page of the document. It uses
\Ref{DjVuFileCache} to do caching thus avoiding unnecessary multiple decoding of
the same page. The real decoding though is accomplished by \Ref{DjVuFile}.
{\bf Messenging.} Being derived from \Ref{DjVuPort}, #DjVuDocument#
takes an active part in exchanging messages (requests and notifications)
between different parties involved in decoding. It reports (relays)
errors, progress information and even handles some requests for data (when
these requests deal with local files).
Typical usage of #DjVuDocument# class in a threadless command line
program would be the following:
\begin{verbatim}
static const char file_name[]="/tmp/document.djvu";
GP<DjVuDocument> doc=DjVuDocument::create_wait(file_name);
const int pages=doc->get_pages_num();
for(int page=0;page<pages;page++)
{
GP<DjVuImage> dimg=doc->get_page(page);
// Do something
};
\end{verbatim}
{\bf Comments for the code above}
\begin{enumerate}
\item Since the document is assumed to be stored on the hard drive,
we don't have to cope with \Ref{DjVuPort}s and can pass
#ZERO# pointer to the \Ref{init}() function. #DjVuDocument#
can access local data itself. In the case of a plugin though,
one would have to implement his own \Ref{DjVuPort}, which
would handle requests for data arising when the document
is being decoded.
\item In a threaded program instead of calling the \Ref{init}()
function one can call \Ref{start_init}() and \Ref{stop_init}()
to initiate and interrupt initialization carried out in
another thread. This possibility of initializing the document
in another thread has been added specially for the plugin
because the initialization itself requires data, which is
not immediately available in the plugin. Thus, to prevent the
main thread from blocking, we perform initialization in a
separate thread. To check if the class is completely and
successfully initialized, use \Ref{is_init_ok}(). To see if
there was an error, use \Ref{is_init_failed}(). To
know when initialization is over (whether successfully or not),
use \Ref{is_init_complete}(). To wait for this to happen use
\Ref{wait_for_complete_init}(). Once again, all these things are
not required for single-threaded program.
Another difference between single-threaded and multi-threaded
environments is that in a single-threaded program, the image is
fully decoded before it's returned. In a multi-threaded
application decoding starts in a separate thread, and the pointer
to the \Ref{DjVuImage} being decoded is returned immediately.
This has been done to enable progressive redisplay
in the DjVu plugin. Use communication mechanism provided by
\Ref{DjVuPort} and \Ref{DjVuPortcaster} to learn about progress
of decoding. Or try #dimg->wait_for_complete_decode()# to wait
until the decoding ends.
\item See Also: \Ref{DjVuFile}, \Ref{DjVuImage}, \Ref{GOS}.
\end{enumerate}
{\bf Initialization}
As mentioned above, the #DjVuDocument# can go through several stages
of initialization. The functionality is gradually added while it passes
one stage after another:
\begin{enumerate}
\item First of all, immediately after the object is created \Ref{init}()
or \Ref{start_init}() functions must be called. {\bf Nothing}
will work until this is done. \Ref{init}() function will not
return until the initialization is complete. You need to make
sure, that enough data is available. {\bf Do not call \Ref{init}()
in the plugin}. \Ref{start_init}() will start initialization
in another thread. Use \Ref{stop_init}() to interrupt it.
Use \Ref{is_init_complete}() to check the initialization progress.
Use \Ref{wait_for_complete_init}() to wait for init to finish.
\item The first thing the initializing code learns about the document
is its type (#BUNDLED#, #INDIRECT#, #OLD_BUNDLED# or #OLD_INDEXED#).
As soon as it happens, document flags are changed and
#notify_doc_flags_changed()# request is sent through the
communication mechanism provided by \Ref{DjVuPortcaster}.
\item After the document type becomes known, the initializing code
proceeds with learning the document structure. Gradually the
flags are updated with values:
\begin{itemize}
\item #DOC_DIR_KNOWN#: Contents of the document became known.
This is meaningful for #BUNDLED#, #OLD_BUNDLED# and
#INDIRECT# documents only.
\item #DOC_NDIR_KNOWN#: Contents of the document navigation
directory became known. This is meaningful for old-style
documents (#OLD_BUNDLED# and #OLD_INDEXED#) only
\item #DOC_INIT_OK# or #DOC_INIT_FAILED#:
The initializating code finished.
\end{itemize}
\end{enumerate} */
class DJVUAPI DjVuDocument : public DjVuPort
{
public:
/** Flags describing the document initialization state.
\begin{itemize}
\item #DOC_TYPE_KNOWN#: The type of the document has been learnt.
\item #DOC_DIR_KNOWN#: Contents of the document became known.
This is meaningful for #BUNDLED#, #OLD_BUNDLED# and
#INDIRECT# documents only.
\item #DOC_NDIR_KNOWN#: Contents of the document navigation
directory became known. This is meaningful for old-style
documents (#OLD_BUNDLED# and #OLD_INDEXED#) only
\item #DOC_INIT_OK#: The initialization has completed successfully.
\item #DOC_INIT_FAILED#: The initialization failed.
\end{itemize} */
enum DOC_FLAGS { DOC_TYPE_KNOWN=1, DOC_DIR_KNOWN=2,
DOC_NDIR_KNOWN=4, DOC_INIT_OK=8,
DOC_INIT_FAILED=16 };
/** Specifies the format of #DjVuDocument#. There are currently 4 DjVu
multipage formats recognized by the library. Two of them are obsolete
and should not be used.
\begin{enumerate}
\item #OLD_BUNDLED# - Obsolete bundled format
\item #OLD_INDEXED# - Obsolete multipage format where every page
is stored in a separate file and "includes" (by means
of an #INCL# chunk) the file with the document directory.
\item #SINGLE_PAGE# - Single page document. Basically a file
with either #FORM:DJVU# or #FORM:IW44# and no multipage
information. For example, #OLD_INDEXED# documents with
document directory do not qualify even if they contain only
one page.
\item #BUNDLED# - Currently supported bundled format
\item #INDIRECT# - Currently supported "expanded" format, where
every page and component is stored in a separate file. There
is also a {\em top-level} file with the document directory.
\end{enumerate} */
enum DOC_TYPE { OLD_BUNDLED=1, OLD_INDEXED, BUNDLED, INDIRECT,
SINGLE_PAGE, UNKNOWN_TYPE };
enum THREAD_FLAGS { STARTED=1, FINISHED=2 };
protected:
/** Default creator. Please call functions \Ref{init}() or
\Ref{start_init}() before you start working with the #DjVuDocument#.
*/
DjVuDocument(void);
public:
/// Virtual Destructor
virtual ~DjVuDocument(void);
/** Initializes the #DjVuDocument# object using an existing document.
This function should be called once after creating the object.
The #url# should point to the real data, and the creator of the
document should be ready to return this data to the document
if it's not stored locally (in which case #DjVuDocument# can
access it itself).
{\bf Initializing thread}
In a single-threaded application, the #start_init()# function performs
the complete initialization of the #DjVuDocument# before it returns.
In a multi-threaded application, though, it initializes some internal
variables, requests data for the document and starts a new
{\em initializing} thread, which is responsible for determining the
document type and structure and completing the initialization
process. This additional complication is justified in the case of
the DjVu plugin because performing initialization requires data and
in the plugin the data can be supplied by the main thread only.
Thus, if the initialization was completed by the main thread, the
plugin would run out of data and block.
{\bf Stages of initialization}
Immediately after the #start_init()# function terminates, the
#DjVuDocument# object is ready for use. Its functionality will
not be complete (until the initializing thread finishes), but
the object is still very useful. Such functions as \Ref{get_page}()
or \Ref{get_djvu_file}() or \Ref{id_to_url}() may be called
before the initializing thread completes. This allows the DjVu
plugin start decoding as soon as possible without waiting for
all data to arrive.
To query the current stage of initialization you can use
\Ref{get_doc_flags}() function or listen to the
#notify_doc_flags_changed()# notifications distributed with the help
of \Ref{DjVuPortcaster}. To wait for the initialization to
complete use \Ref{wait_for_complete_init}(). To stop initialization
call \Ref{stop_init}().
{\bf Querying data}
The query for data is done using the communication mechanism
provided by \Ref{DjVuPort} and \Ref{DjVuPortcaster}. If #port#
is not #ZERO#, then the request for data will be forwarded to it.
If it {\bf is} #ZERO# then #DjVuDocument# will create an internal
instance of \Ref{DjVuSimplePort} and will use it to access local
files and report errors to #stderr#. In short, if the document
file is stored on the local hard disk, and you're OK about reporting
errors to #stderr#, you may pass #ZERO# pointer to \Ref{DjVuPort}
as #DjVuDocument# can take care of this situation by itself.
{\bf The URL}
Depending on the document type the #url# should point to:
\begin{itemize}
\item {\bf Old bundled} and {\bf New bundled} formats: to the
document itself.
\item {\bf Old indexed} format: to any page of the document.
\item {\bf New indirect} format: to the top-level file of the
document. If (like in the {\em old indexed} format) you
point the #url# to a page, the page {\em will} be decoded,
but it will {\em not} be recognized to be part of the
document.
\end{itemize}
@param url The URL pointing to the document. If the document is
in a {\em bundled} format then the URL should point to it.
If the document is in the {\em old indexed} format then
URL may point to any page of this document. For {\em new
indirect} format the URL should point to the top-level
file of the document.
@param port If not #ZERO#, all requests and notifications will
be sent to it. Otherwise #DjVuDocument# will create an internal
instance of \Ref{DjVuSimplePort} for these purposes.
It's OK to make it #ZERO# if you're writing a command line
tool, which should work with files on the hard disk only
because #DjVuDocument# can access such files itself.
@param cache It's used to cache decoded \Ref{DjVuFile}s and
is actually useful in the plugin only. */
void start_init(const GURL & url, GP<DjVuPort> port=0,
DjVuFileCache * cache=0);
/** This creates a DjVuDocument without initializing it. */
static GP<DjVuDocument> create_noinit(void) {return new DjVuDocument;}
/** Create a version of DjVuDocument which has finished initializing. */
static GP<DjVuDocument> create_wait(
const GURL &url, GP<DjVuPort> xport=0, DjVuFileCache * const xcache=0);
/** Create a version of DjVuDocument which has begun initializing. */
static GP<DjVuDocument> create(
const GURL &url, GP<DjVuPort> xport=0, DjVuFileCache * const xcache=0);
/** Create a version of DjVuDocument which has begun initializing. */
static GP<DjVuDocument> create(
GP<DataPool> pool, GP<DjVuPort> xport=0, DjVuFileCache * const xcache=0);
/** Create a version of DjVuDocument which has begun initializing. */
static GP<DjVuDocument> create(
const GP<ByteStream> &bs, GP<DjVuPort> xport=0,
DjVuFileCache * const xcache=0);
/** Call this function when you don't need the #DjVuDocument# any more.
In a multi-threaded environment it will stop initialization
thread, if it is currently running. {\bf You will not be able
to start the initialization again. Thus, after calling this
function the document should not be used any more}. */
void stop_init(void);
/** Initializes the document.
Contrary to \Ref{start_init}(), which just starts the initialization
thread in a multi-threaded environment, this function does not
return until the initialization completes (either successfully or
not). Basically, it calls \Ref{start_init}() and then
\Ref{wait_for_complete_init}().
*/
void init(const GURL & url, GP<DjVuPort> port=0,
DjVuFileCache * cache=0);
/** Returns #TRUE# if the initialization thread finished (does not
matter successfully or not). As soon as it happens, the document
becomes completely initialized and its every function should work
properly. Please refer to the description of \Ref{init}() function
and of the #DjVuDocument# class to learn about the initializing
stages.
To wait for the initialization to complete use
\Ref{wait_for_complete_init}() function.
To query the initialization stage use \Ref{get_flags}() function.
To learn whether initialization was successful or not,
use \Ref{is_init_ok}() and \Ref{is_init_failed}().
{\bf Note:} In a single threaded application the initialization
completes before the \Ref{init}() function returns. */
bool is_init_complete(void) const;
/** Returns #TRUE# is the initialization thread finished successfully.
See \Ref{is_init_complete}() and \Ref{wait_for_complete_init}()
for more details. */
bool is_init_ok(void) const;
/** Forces compression with the next save_as function. */
void set_needs_compression(void);
/** Returns #TRUE# if there are uncompressed pages in this document. */
bool needs_compression(void) const;
/** Returns #TRUE# if this file must be renamed before saving. */
bool needs_rename(void) const;
/** Returns #TRUE# if this file must be renamed before saving. */
bool can_compress(void) const;
/** Returns #TRUE# is the initialization thread failed.
See \Ref{is_init_complete}() and \Ref{wait_for_complete_init}()
for more details. */
bool is_init_failed(void) const;
/** If the document has already learnt its type, the function will
returns it: #DjVuDocument::OLD_BUNDLED# or
#DjVuDocument::OLD_INDEXED# or #DjVuDocument::SINGLE_PAGE# or
#DjVuDocument:BUNDLED# or #DjVuDocument::INDIRECT#. The first
two formats are obsolete. Otherwise (if the type is unknown yet),
#UNKNOWN_TYPE# will be returned.
{\bf Note:} To check the stage of the document initialization
use \Ref{get_flags}() or \Ref{is_init_complete}() functions. To
wait for the initialization to complete use \Ref{wait_for_complete_init}().
For single threaded applications the initialization completes
before the \Ref{init}() function returns. */
int get_doc_type(void) const;
/** Returns the document flags. The flags describe the degree in which
the #DjVuDocument# object is initialized. Every time the flags
are changed, a #notify_doc_flags_changed()# notification is
distributed using the \Ref{DjVuPortcaster} communication
mechanism.
{\bf Note:} To wait for the initialization to complete use
\Ref{wait_for_complete_init}(). For single threaded applications
the initialization completes before the \Ref{init}() function
returns. */
long get_doc_flags(void) const;
/** Returns #TRUE# if the document is in bundled format (either in
#DjVuDocument::OLD_BUNDLED# or #DjVuDocument::BUNDLED# formats). */
bool is_bundled(void) const;
/// Returns the URL passed to the \Ref{init}() function
GURL get_init_url(void) const;
/// Returns a listing of id's used by this document.
GList<GUTF8String> get_id_list(void);
/// Fill the id's into a GMap.
void map_ids( GMap<GUTF8String,void *> &map);
/** Returns data corresponding to the URL passed to the \Ref{init}()
function.
{\bf Note:} The pointer returned is guaranteed to be non-#ZERO#
only after the #DjVuDocument# learns its type (passes through
the first stage of initialization process). Please refer to
\Ref{init}() for details. */
GP<DataPool> get_init_data_pool(void) const;
/** @name Accessing pages */
//@{
/** Returns the number of pages in the document. If there is still
insufficient information about the document structure (initialization
has not finished yet), #1# will be returned. Please refer to
\Ref{init}() for details. */
int get_pages_num(void) const;
/** Translates the page number to the full URL of the page. This URL
is "artificial" for the {\em bundled} formats and is obtained
by appending the page name to the document's URL honoring possible
#;# and #?# in it. Negative page number has a special meaning for
#OLD_INDEXED# documents: it points to the URL, which the
#DjVuDocument# has been initialized with. For other formats this
is the same as page #0#.
The function tries it best to map the page number to the URL.
Although, if the document structure has not been fully discovered
yet, an empty URL will be returned. Use \Ref{wait_for_complete_init}()
to wait until the document initialization completes. Refer to
\Ref{init}() for details.
Depending on the document format, the function assumes, that there
is enough information to complete the request when:
\begin{itemize}
\item #OLD_INDEXED#: If #page_num<0#, #DOC_TYPE_KNOWN# flag must
be set. Otherwise #DOC_NDIR_KNOWN# must be set.
\item #OLD_BUNDLED#: If #page_num=0#, #DOC_DIR_KNOWN# flag must
be set. Otherwise #DOC_NDIR_KNOWN# flag must be set.
\item #INDIRECT# and #BUNDLED#: #DOC_DIR_KNOWN# flag must be set.
\end{itemize} */
GURL page_to_url(int page_num) const;
/// Tranlate the page number to id...
GUTF8String page_to_id(int page_num) const
{ return url_to_id(page_to_url(page_num)); }
/** Translates the page URL back to page number. Returns #-1# if the
page is not in the document or the document's structure
has not been learnt yet.
Depending on the document format, the function starts working
properly as soon as:
\begin{itemize}
\item #OLD_INDEXED# and #OLD_BUNDLED# and #SINGLE_PAGE#:
#DOC_NDIR_KNOWN# is set
\item #INDIRECT# and #BUNDLED#: #DOC_DIR_KNOWN# is set.
\end{itemize} */
int url_to_page(const GURL & url) const;
/// Map the specified url to it's id.
GUTF8String url_to_id(const GURL &url) const
{ return url.fname(); }
/** Translates the textual ID to the complete URL if possible.
Depending on the document format the translation is done in the
following way:
\begin{itemize}
\item For #BUNDLED# and #INDIRECT# documents the function
scans the \Ref{DjVmDir} (the document directory) and
matches the ID against:
\begin{enumerate}
\item File ID from the \Ref{DjVmDir}
\item File name from the \Ref{DjVmDir}
\item File title from the \Ref{DjVmDir}
\end{enumerate}
Then for #BUNDLED# document the URL is obtained by
appending the #name# of the found file to the document's
URL.
For #INDIRECT# documents the URL is obtained by
appending the #name# of the found file to the URL of
the directory containing the document.
\item For #OLD_BUNDLED# documents the function compares the ID
with internal name of every file inside the bundle and
composes an artificial URL by appending the file name to
the document's URL.
\item For #OLD_INDEXED# or #SINGLE_PAGE# documents the function
composes the URL by appending the ID to the URL of the
directory containing the document.
\end{itemize}
If information obtained by the initialization thread is not
sufficient yet, the #id_to_url()# may return an empty URL.
Depending on the document type, the information is sufficient when
\begin{itemize}
\item #BUNDLED# and #INDIRECT#: #DOC_DIR_KNOWN# flag is set.
\item #OLD_BUNDLED# and #OLD_INDEXED# and #SINGLE_PAGE#:
#DOC_TYPE_KNOWN# flag is set.
\end{itemize} */
GURL id_to_url(const GUTF8String &id) const;
/// Find out which page this id is...
int id_to_page(const GUTF8String &id) const
{ return url_to_page(id_to_url(id)); }
/** Returns \Ref{GP} pointer to \Ref{DjVuImage} corresponding to page
#page_num#. If caching is enabled, and there is a {\em fully decoded}
\Ref{DjVuFile} in the cache, the image will be reused and will
be returned fully decoded. Otherwise, if multi-threaded behavior
is allowed, and #sync# is set to #FALSE#, the decoding will be
started in a separate thread, which enables to do progressive
redisplay. Thus, in this case the image returned may be partially
decoded.
Negative #page_num# has a special meaning for the {\em old indexed}
multipage documents: the #DjVuDocument# will start decoding of the
URL with which it has been initialized. For other formats page
#-1# is the same as page #0#.
#DjVuDocument# can also connect the created page to the specified
#port# {\em before starting decoding}. This option will allow
the future owner of \Ref{DjVuImage} to receive all messages and
requests generated during its decoding.
If this function is called before the document's structure becomes
known (the initialization process completes), the \Ref{DjVuFile},
which the returned image will be attached to, will be assigned a
temporary artificial URL, which will be corrected as soon as enough
information becomes available. The trick prevents the main thread
from blocking and in some cases helps to start decoding earlier.
The URL is corrected and decoding will start as soon as
#DjVuDocument# passes some given stages of initialization and
\Ref{page_to_url}(), \Ref{id_to_url}() functions start working
properly. Please look through their description for details.
{\bf Note:} To wait for the initialization to complete use
\Ref{wait_for_complete_init}(). For single threaded applications
the initialization completes before the \Ref{init}() function
returns.
@param page_num Number of the page to be decoded
@param sync When set to #TRUE# the function will not return
until the page is completely decoded. Otherwise,
in a multi-threaded program, this function will
start decoding in a new thread and will return
a partially decoded image. Refer to
\Ref{DjVuImage::wait_for_complete_decode}() and
\Ref{DjVuFile::is_decode_ok}().
@param port A pointer to \Ref{DjVuPort}, that the created image
will be connected to. */
GP<DjVuImage> get_page(int page_num, bool sync=true, DjVuPort * port=0) const;
GP<DjVuImage> get_page(int page_num, bool sync=true, DjVuPort * port=0)
{ return const_cast<const DjVuDocument *>(this)->get_page(page_num,sync,port); }
/** Returns \Ref{GP} pointer to \Ref{DjVuImage} corresponding to the
specified ID. This function behaves exactly as the #get_page()#
function above. The only thing worth mentioning here is how the #ID#
parameter is treated.
First of all the function checks, if the ID contains a number.
If so, it just calls the #get_page()# function above. If ID is
#ZERO# or just empty, page number #-1# is assumed. Otherwise
the ID is translated to the URL using \Ref{id_to_url}(). */
GP<DjVuImage> get_page(const GUTF8String &id, bool sync=true, DjVuPort * port=0);
/** Returns \Ref{DjVuFile} corresponding to the specified page.
Normally it translates the page number to the URL using
\Ref{page_to_url}() and then creates \Ref{DjVuFile} initializing
it with data from the URL.
The behavior becomes different, though in the case when the
document structure is unknown at the moment this function is called.
In this situations it invents a temporary URL, creates a
\Ref{DjVuFile}, initializes it with this URL and returns
immediately. The caller may start decoding the file right away
(if necessary). The decoding will block but will automatically
continue as soon as enough information is collected about the
document. This trick should be quite transparent to the user and
helps to prevent the main thread from blocking. The decoding will
unblock and this function will stop using this "trick" as soon
as #DjVuDocument# passes some given stages of initialization and
\Ref{page_to_url}(), \Ref{id_to_url}() functions start working
properly.
If #dont_create# is #FALSE# the function will return the file
only if it already exists.
{\bf Note:} To wait for the initialization to complete use
\Ref{wait_for_complete_init}(). For single threaded applications
the initialization completes before the \Ref{init}() function
returns. */
GP<DjVuFile> get_djvu_file(int page_num, bool dont_create=false) const;
GP<DjVuFile> get_djvu_file(int page_num, bool dont_create=false)
{ return const_cast<const DjVuDocument *>(this)->get_djvu_file(page_num,dont_create); }
/** Returns \Ref{DjVuFile} corresponding to the specified ID.
This function behaves exactly as the #get_djvu_file()# function
above. The only thing worth mentioning here is how the #ID#
parameter is treated.
First off, \Ref{id_to_url}() is called. If not successfull,
the function checks, if the ID contains a number.
If so, it just calls the #get_djvu_file()# function above. If ID is
#ZERO# or just empty, page number #-1# is assumed.
If #dont_create# is #FALSE# the function will return the file
only if it already exists. */
GP<DjVuFile> get_djvu_file(const GUTF8String &id, bool dont_create=false);
GP<DjVuFile> get_djvu_file(const GURL &url, bool dont_create=false);
/** Returns a \Ref{DataPool} containing one chunk #TH44# with
the encoded thumbnail for the specified page. The function
first looks for thumbnails enclosed into the document and if
it fails to find one, it decodes the required page and creates
the thumbnail on the fly (unless #dont_decode# is true).
{\bf Note:} It may happen that the returned \Ref{DataPool} will
not contain all the data you need. In this case you will need
to install a trigger into the \Ref{DataPool} to learn when the
data actually arrives. */
virtual GP<DataPool> get_thumbnail(int page_num, bool dont_decode);
/* Will return gamma correction, which was used when creating
thumbnail images. If you need other gamma correction, you will
need to correct the thumbnails again. */
float get_thumbnails_gamma(void) const;
//@}
/** Waits until the document initialization process finishes.
It can finish either successfully or not. Use \Ref{is_init_ok}()
and \Ref{is_init_failed}() to learn the result code.
As described in \Ref{start_init}(), for multi-threaded applications the
initialization is carried out in parallel with the main thread.
This function blocks the calling thread until the initializing
thread reads enough data, receives information about the document
format and exits. This function returns #true# if the
initialization is successful. You can use \Ref{get_flags}() or
\Ref{is_init_complete}() to check more precisely the degree of
initialization. Use \Ref{stop_init}() to interrupt initialization. */
bool wait_for_complete_init(void);
/** Wait until we known the number of pages and return. */
int wait_get_pages_num(void) const;
/// Returns cache being used.
DjVuFileCache * get_cache(void) const;
/** @name Saving document to disk */
//@{
/** Returns pointer to the \Ref{DjVmDoc} class, which can save the
document contents on the hard disk in one of the two new formats:
{\em bundled} and {\em indirect}. You may also want to look
at \Ref{write}() and \Ref{expand}() if you are interested in
how to save the document.
{\bf Plugin Warning}. This function will read contents of the whole
document. Thus, if you call it from the main thread (the thread,
which transfers data from Netscape), the plugin will block. */
GP<DjVmDoc> get_djvm_doc(void);
/** Saves the document in the {\em new bundled} format. All the data
is "bundled" into one file and this file is written into the
passed stream.
If #force_djvm# is #TRUE# then even one page documents will be
saved in the #DJVM BUNDLED# format (inside a #FORM:DJVM#);
{\bf Plugin Warning}. This function will read contents of the whole
document. Thus, if you call it from the main thread (the thread,
which transfers data from Netscape), the plugin will block. */
virtual void write(const GP<ByteStream> &str, bool force_djvm=false);
/** Always save as bundled, renaming any files conflicting with the
the names in the supplied GMap. */
virtual void write(const GP<ByteStream> &str,
const GMap<GUTF8String,void *> &reserved);
/** Saves the document in the {\em new indirect} format when every
page and component are stored in separate files. This format
is ideal for web publishing because it allows direct access to
any page and component. In addition to it, a top-level file
containing the list of all components will be created. To view
the document later in the plugin or in the viewer one should
load the top-level file.
{\bf Plugin Warning}. This function will read contents of the whole
document. Thus, if you call it from the main thread (the thread,
which transfers data from Netscape), the plugin will block.
@param codebase - Name of the directory which the document should
be expanded into.
@param idx_name - Name of the top-level file containing the document
directory (basically, list of all files composing the document).
*/
void expand(const GURL &codebase, const GUTF8String &idx_name);
/** This function can be used instead of \Ref{write}() and \Ref{expand}().
It allows to save the document either in the new #BUNDLED# format
or in the new #INDIRECT# format depending on the value of parameter
#bundled#.
Depending on the document's type, the meaning of #where# is:
\begin{itemize}
\item For #BUNDLED# documents this is the name of the file
\item For #INDIRECT# documents this is the name of top-level
index file. All document files will be saved into the
save directory where the index file will resize. */
virtual void save_as(const GURL &where, bool bundled=0);
//@}
/** Returns pointer to the internal directory of the document, if it
is in one of the new formats: #BUNDLED# or #INDIRECT#.
Otherwise (if the format of the input document is obsolete),
#ZERO# is returned.
#ZERO# will also be returned if the initializing thread has not
learnt enough information about the document (#DOC_DIR_KNOWN# has
not been set yet). Check \Ref{is_init_complete}() and \Ref{init}()
for details. */
GP<DjVmDir> get_djvm_dir(void) const;
/** Returns pointer to the document bookmarks.
This applies to #BUNDLED# and #INDIRECT# documents.
#ZERO# will also be returned if the initializing thread has not
learnt enough information about the document (#DOC_DIR_KNOWN# has
not been set yet). Check \Ref{is_init_complete}() and \Ref{init}()
for details. */
GP<DjVmNav> get_djvm_nav(void) const;
/** Returns pointer to the internal directory of the document, if it
is in obsolete #OLD_BUNDLED# format.
#ZERO# will also be returned if the initializing thread has not
learnt enough information about the document (#DOC_DIR_KNOWN# has
not been set yet). Check \Ref{is_init_complete}() and \Ref{init}()
for details. */
GP<DjVmDir0> get_djvm_dir0(void) const;
/** Returns pointer to {\em navigation directory} of the document.
The navigation directory is a DjVu file containing only one
chunk #NDIR# inside a #FORM:DJVI# with the list of all
document pages. */
GP<DjVuNavDir> get_nav_dir(void) const;
/// Create a complete DjVuXML file.
void writeDjVuXML(const GP<ByteStream> &gstr_out,
int flags, int page = -1) const;
/// Returns TRUE if #class_name# is #"DjVuDocument"# or #"DjVuPort"#
virtual bool inherits(const GUTF8String &class_name) const;
/// Converts the specified id to a URL.
virtual GURL id_to_url(const DjVuPort * source, const GUTF8String &id);
virtual GP<DjVuFile> id_to_file(const DjVuPort * source, const GUTF8String &id);
virtual GP<DataPool> request_data(const DjVuPort * source, const GURL & url);
virtual void notify_file_flags_changed(const DjVuFile * source,
long set_mask, long clr_mask);
virtual GList<GURL> get_url_names(void);
virtual void set_recover_errors(ErrorRecoveryAction=ABORT);
virtual void set_verbose_eof(bool=true);
static void set_compress_codec(
void (*codec)(GP<ByteStream> &, const GURL &where, bool bundled));
static void set_import_codec(
void (*codec)(GP<DataPool> &,const GURL &url,bool &, bool &));
protected:
static void (*djvu_import_codec) (
GP<DataPool> &pool, const GURL &url,bool &needs_compression, bool &needs_rename );
static void (*djvu_compress_codec) (
GP<ByteStream> &bs, const GURL &where, bool bundled);
virtual GP<DjVuFile> url_to_file(const GURL & url, bool dont_create=false) const;
GURL init_url;
GP<DataPool> init_data_pool;
GP<DjVmDir> djvm_dir; // New-style DjVm directory
GP<DjVmNav> djvm_nav;
int doc_type;
bool needs_compression_flag;
bool can_compress_flag;
bool needs_rename_flag;
bool has_url_names;
GCriticalSection url_names_lock;
GList<GURL> url_names;
ErrorRecoveryAction recover_errors;
bool verbose_eof;
public:
class UnnamedFile; // This really should be protected ...
class ThumbReq; // This really should be protected ...
protected:
bool init_started;
GSafeFlags flags;
GSafeFlags init_thread_flags;
DjVuFileCache * cache;
GP<DjVuSimplePort> simple_port;
GP<DjVmDir0> djvm_dir0; // Old-style DjVm directory
GP<DjVuNavDir> ndir; // Old-style navigation directory
GUTF8String first_page_name;// For OLD_BUNDLED docs only
// The following is used in init() and destructor to query NDIR
// DO NOT USE FOR ANYTHING ELSE. THE FILE IS ZEROED IMMEDIATELY
// AFTER IT'S NO LONGER NEEDED. If you don't zero it, ~DjVuDocument()
// will kill it, which is a BAD thing if the file's already in cache.
GP<DjVuFile> ndir_file;
GPList<UnnamedFile> ufiles_list;
GCriticalSection ufiles_lock;
GPList<ThumbReq> threqs_list;
GCriticalSection threqs_lock;
GP<DjVuDocument> init_life_saver;
static const float thumb_gamma;
// Reads document contents in another thread trying to determine
// its type and structure
GThread init_thr;
static void static_init_thread(void *);
void init_thread(void);
void check() const;
void process_threqs(void);
GP<ThumbReq> add_thumb_req(const GP<ThumbReq> & thumb_req);
void add_to_cache(const GP<DjVuFile> & f);
void check_unnamed_files(void);
GUTF8String get_int_prefix(void) const;
void set_file_aliases(const DjVuFile * file);
GURL invent_url(const GUTF8String &name) const;
};
class DjVuDocument::UnnamedFile : public GPEnabled
{
public:
enum { ID, PAGE_NUM };
int id_type;
GUTF8String id;
int page_num;
GURL url;
GP<DjVuFile> file;
GP<DataPool> data_pool;
protected:
UnnamedFile(int xid_type, const GUTF8String &xid, int xpage_num, const GURL & xurl,
const GP<DjVuFile> & xfile) :
id_type(xid_type), id(xid), page_num(xpage_num), url(xurl), file(xfile) {}
friend class DjVuDocument;
};
class DjVuDocument::ThumbReq : public GPEnabled
{
public:
int page_num;
GP<DataPool> data_pool;
// Either of the next two blocks should present
GP<DjVuFile> image_file;
int thumb_chunk;
GP<DjVuFile> thumb_file;
protected:
ThumbReq(int xpage_num, const GP<DataPool> & xdata_pool) :
page_num(xpage_num), data_pool(xdata_pool) {}
friend class DjVuDocument;
};
inline void
DjVuDocument::init(const GURL &url, GP<DjVuPort> port, DjVuFileCache *cache)
{
start_init(url,port,cache);
wait_for_complete_init();
}
inline GP<DjVuDocument>
DjVuDocument::create(
const GURL &url, GP<DjVuPort> xport, DjVuFileCache * const xcache)
{
DjVuDocument *doc=new DjVuDocument;
GP<DjVuDocument> retval=doc;
doc->start_init(url,xport,xcache);
return retval;
}
inline bool
DjVuDocument::is_init_complete(void) const
{
return (flags & (DOC_INIT_OK | DOC_INIT_FAILED))!=0;
}
inline bool
DjVuDocument::is_init_ok(void) const
{
return (flags & DOC_INIT_OK)!=0;
}
inline void
DjVuDocument::set_needs_compression(void)
{
needs_compression_flag=true;
}
inline bool
DjVuDocument::needs_compression(void) const
{
return needs_compression_flag;
}
inline bool
DjVuDocument::needs_rename(void) const
{
return needs_rename_flag;
}
inline bool
DjVuDocument::can_compress(void) const
{
return can_compress_flag;
}
inline bool
DjVuDocument::is_init_failed(void) const
{
return (flags & DOC_INIT_FAILED)!=0;
}
inline int
DjVuDocument::get_doc_type(void) const { return doc_type; }
inline long
DjVuDocument::get_doc_flags(void) const { return flags; }
inline bool
DjVuDocument::is_bundled(void) const
{
return doc_type==BUNDLED || doc_type==OLD_BUNDLED;
}
inline GURL
DjVuDocument::get_init_url(void) const { return init_url; }
inline GP<DataPool>
DjVuDocument::get_init_data_pool(void) const { return init_data_pool; }
inline bool
DjVuDocument::inherits(const GUTF8String &class_name) const
{
return
(GUTF8String("DjVuDocument") == class_name) ||
DjVuPort::inherits(class_name);
// !strcmp("DjVuDocument", class_name) ||
// DjVuPort::inherits(class_name);
}
inline float
DjVuDocument::get_thumbnails_gamma(void) const
{
return thumb_gamma;
}
inline DjVuFileCache *
DjVuDocument::get_cache(void) const
{
return cache;
}
inline GP<DjVmDir>
DjVuDocument::get_djvm_dir(void) const
{
if (doc_type==SINGLE_PAGE)
G_THROW( ERR_MSG("DjVuDocument.no_dir") );
if (doc_type!=BUNDLED && doc_type!=INDIRECT)
G_THROW( ERR_MSG("DjVuDocument.obsolete") );
return djvm_dir;
}
inline GP<DjVmNav>
DjVuDocument::get_djvm_nav(void) const
{
if (doc_type==BUNDLED || doc_type==INDIRECT)
return djvm_nav;
return 0;
}
inline GP<DjVmDir0>
DjVuDocument::get_djvm_dir0(void) const
{
if (doc_type!=OLD_BUNDLED)
G_THROW( ERR_MSG("DjVuDocument.old_bundle") );
return djvm_dir0;
}
inline GP<DjVuNavDir>
DjVuDocument::get_nav_dir(void) const
{
return ndir;
}
inline void
DjVuDocument::set_recover_errors(ErrorRecoveryAction recover)
{
recover_errors=recover;
}
inline void
DjVuDocument::set_verbose_eof(bool verbose)
{
verbose_eof=verbose;
}
//@}
#ifdef HAVE_NAMESPACES
}
# ifndef NOT_USING_DJVU_NAMESPACE
using namespace DJVU;
# endif
#endif
#endif
| [
"[email protected]"
] | |
d8fbef9d3588906ee34ce74f716352b67f50dd98 | ea4f2445a0c97b427e5827138246129f28059a3d | /cpp/CRTP.cpp | a0f6e74f5ad1aed4fead494cb1a4463bd7fdbe17 | [
"MIT"
] | permissive | so61pi/examples | 27cfe8a3e7712b25d2f344312f64fd4d4bdeeca3 | 38e2831cd6517864fc05f499f72fbb4ff6ae27c0 | refs/heads/master | 2023-01-22T04:13:27.785531 | 2020-04-30T14:07:36 | 2020-04-30T14:07:36 | 116,532,548 | 5 | 1 | MIT | 2023-01-05T00:47:46 | 2018-01-07T02:56:36 | C | UTF-8 | C++ | false | false | 541 | cpp | #include <iostream>
template<typename Derived>
class Base {
public:
void Show() {
static_cast<Derived *>(this)->DoShow();
}
};
class Derived1 : public Base < Derived1 >
{
public:
void DoShow() {
std::cout << "Derived1::DoShow\n";
}
};
class Derived2 : public Base < Derived2 >
{
public:
void DoShow() {
std::cout << "Derived2::DoShow\n";
}
};
int main() {
Derived1 d1;
Derived2 d2;
Base<Derived1> *b1 = &d1;
Base<Derived2> *b2 = &d2;
b1->Show();
b2->Show();
}
| [
"[email protected]"
] | |
8f1b85bc0342540af1508de10bd8b3a237950275 | 7d45c499952bbfdcd1c1b048fc26f9a5e6a7ab2c | /src/wallet/db.h | 6470347827dc459c6a238b5a9acad3e18a58731e | [
"MIT"
] | permissive | fl0wd3v/Credits | 8db91c8058bbe10f31dae4c2ef7dc48ed064308e | e546cb7c82b809af822540fcfb02a88e0936babf | refs/heads/master | 2021-01-25T04:21:58.407408 | 2017-06-21T17:35:12 | 2017-06-21T17:35:12 | 94,998,709 | 1 | 0 | null | 2017-06-21T11:53:07 | 2017-06-21T11:53:07 | null | UTF-8 | C++ | false | false | 8,861 | h | // Copyright (c) 2009-2017 Satoshi Nakamoto
// Copyright (c) 2009-2017 The Bitcoin Developers
// Copyright (c) 2014-2017 The Dash Core Developers
// Copyright (c) 2017 Credits Developers
// Distributed under the MIT/X11 software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
#ifndef CREDITS_WALLET_DB_H
#define CREDITS_WALLET_DB_H
#include "clientversion.h"
#include "serialize.h"
#include "streams.h"
#include "sync.h"
#include "version.h"
#include <db_cxx.h>
#include <map>
#include <string>
#include <vector>
#include <boost/filesystem/path.hpp>
static const unsigned int DEFAULT_WALLET_DBLOGSIZE = 100;
static const bool DEFAULT_WALLET_PRIVDB = true;
extern unsigned int nWalletDBUpdated;
class CDBEnv
{
private:
bool fDbEnvInit;
bool fMockDb;
// Don't change into boost::filesystem::path, as that can result in
// shutdown problems/crashes caused by a static initialized internal pointer.
std::string strPath;
void EnvShutdown();
public:
mutable CCriticalSection cs_db;
DbEnv *dbenv;
std::map<std::string, int> mapFileUseCount;
std::map<std::string, Db*> mapDb;
CDBEnv();
~CDBEnv();
void Reset();
void MakeMock();
bool IsMock() { return fMockDb; }
/**
* Verify that database file strFile is OK. If it is not,
* call the callback to try to recover.
* This must be called BEFORE strFile is opened.
* Returns true if strFile is OK.
*/
enum VerifyResult { VERIFY_OK,
RECOVER_OK,
RECOVER_FAIL };
VerifyResult Verify(const std::string& strFile, bool (*recoverFunc)(CDBEnv& dbenv, const std::string& strFile));
/**
* Salvage data from a file that Verify says is bad.
* fAggressive sets the DB_AGGRESSIVE flag (see berkeley DB->verify() method documentation).
* Appends binary key/value pairs to vResult, returns true if successful.
* NOTE: reads the entire database into memory, so cannot be used
* for huge databases.
*/
typedef std::pair<std::vector<unsigned char>, std::vector<unsigned char> > KeyValPair;
bool Salvage(const std::string& strFile, bool fAggressive, std::vector<KeyValPair>& vResult);
bool Open(const boost::filesystem::path& path);
void Close();
void Flush(bool fShutdown);
void CheckpointLSN(const std::string& strFile);
void CloseDb(const std::string& strFile);
bool RemoveDb(const std::string& strFile);
DbTxn* TxnBegin(int flags = DB_TXN_WRITE_NOSYNC)
{
DbTxn* ptxn = NULL;
int ret = dbenv->txn_begin(NULL, &ptxn, flags);
if (!ptxn || ret != 0)
return NULL;
return ptxn;
}
};
extern CDBEnv bitdb;
/** RAII class that provides access to a Berkeley database */
class CDB
{
protected:
Db* pdb;
std::string strFile;
DbTxn* activeTxn;
bool fReadOnly;
bool fFlushOnClose;
explicit CDB(const std::string& strFilename, const char* pszMode = "r+", bool fFlushOnCloseIn=true);
~CDB() { Close(); }
public:
void Flush();
void Close();
private:
CDB(const CDB&);
void operator=(const CDB&);
protected:
template <typename K, typename T>
bool Read(const K& key, T& value)
{
if (!pdb)
return false;
// Key
CDataStream ssKey(SER_DISK, CLIENT_VERSION);
ssKey.reserve(1000);
ssKey << key;
Dbt datKey(&ssKey[0], ssKey.size());
// Read
Dbt datValue;
datValue.set_flags(DB_DBT_MALLOC);
int ret = pdb->get(activeTxn, &datKey, &datValue, 0);
memory_cleanse(datKey.get_data(), datKey.get_size());
bool success = false;
if (datValue.get_data() != NULL) {
// Unserialize value
try {
CDataStream ssValue((char*)datValue.get_data(), (char*)datValue.get_data() + datValue.get_size(), SER_DISK, CLIENT_VERSION);
ssValue >> value;
success = true;
} catch (const std::exception&) {
// In this case success remains 'false'
}
// Clear and free memory
memory_cleanse(datValue.get_data(), datValue.get_size());
free(datValue.get_data());
}
return ret == 0 && success;
}
template <typename K, typename T>
bool Write(const K& key, const T& value, bool fOverwrite = true)
{
if (!pdb)
return false;
if (fReadOnly)
assert(!"Write called on database in read-only mode");
// Key
CDataStream ssKey(SER_DISK, CLIENT_VERSION);
ssKey.reserve(1000);
ssKey << key;
Dbt datKey(&ssKey[0], ssKey.size());
// Value
CDataStream ssValue(SER_DISK, CLIENT_VERSION);
ssValue.reserve(10000);
ssValue << value;
Dbt datValue(&ssValue[0], ssValue.size());
// Write
int ret = pdb->put(activeTxn, &datKey, &datValue, (fOverwrite ? 0 : DB_NOOVERWRITE));
// Clear memory in case it was a private key
memory_cleanse(datKey.get_data(), datKey.get_size());
memory_cleanse(datValue.get_data(), datValue.get_size());
return (ret == 0);
}
template <typename K>
bool Erase(const K& key)
{
if (!pdb)
return false;
if (fReadOnly)
assert(!"Erase called on database in read-only mode");
// Key
CDataStream ssKey(SER_DISK, CLIENT_VERSION);
ssKey.reserve(1000);
ssKey << key;
Dbt datKey(&ssKey[0], ssKey.size());
// Erase
int ret = pdb->del(activeTxn, &datKey, 0);
// Clear memory
memory_cleanse(datKey.get_data(), datKey.get_size());
return (ret == 0 || ret == DB_NOTFOUND);
}
template <typename K>
bool Exists(const K& key)
{
if (!pdb)
return false;
// Key
CDataStream ssKey(SER_DISK, CLIENT_VERSION);
ssKey.reserve(1000);
ssKey << key;
Dbt datKey(&ssKey[0], ssKey.size());
// Exists
int ret = pdb->exists(activeTxn, &datKey, 0);
// Clear memory
memory_cleanse(datKey.get_data(), datKey.get_size());
return (ret == 0);
}
Dbc* GetCursor()
{
if (!pdb)
return NULL;
Dbc* pcursor = NULL;
int ret = pdb->cursor(NULL, &pcursor, 0);
if (ret != 0)
return NULL;
return pcursor;
}
int ReadAtCursor(Dbc* pcursor, CDataStream& ssKey, CDataStream& ssValue, unsigned int fFlags = DB_NEXT)
{
// Read at cursor
Dbt datKey;
if (fFlags == DB_SET || fFlags == DB_SET_RANGE || fFlags == DB_GET_BOTH || fFlags == DB_GET_BOTH_RANGE) {
datKey.set_data(&ssKey[0]);
datKey.set_size(ssKey.size());
}
Dbt datValue;
if (fFlags == DB_GET_BOTH || fFlags == DB_GET_BOTH_RANGE) {
datValue.set_data(&ssValue[0]);
datValue.set_size(ssValue.size());
}
datKey.set_flags(DB_DBT_MALLOC);
datValue.set_flags(DB_DBT_MALLOC);
int ret = pcursor->get(&datKey, &datValue, fFlags);
if (ret != 0)
return ret;
else if (datKey.get_data() == NULL || datValue.get_data() == NULL)
return 99999;
// Convert to streams
ssKey.SetType(SER_DISK);
ssKey.clear();
ssKey.write((char*)datKey.get_data(), datKey.get_size());
ssValue.SetType(SER_DISK);
ssValue.clear();
ssValue.write((char*)datValue.get_data(), datValue.get_size());
// Clear and free memory
memory_cleanse(datKey.get_data(), datKey.get_size());
memory_cleanse(datValue.get_data(), datValue.get_size());
free(datKey.get_data());
free(datValue.get_data());
return 0;
}
public:
bool TxnBegin()
{
if (!pdb || activeTxn)
return false;
DbTxn* ptxn = bitdb.TxnBegin();
if (!ptxn)
return false;
activeTxn = ptxn;
return true;
}
bool TxnCommit()
{
if (!pdb || !activeTxn)
return false;
int ret = activeTxn->commit(0);
activeTxn = NULL;
return (ret == 0);
}
bool TxnAbort()
{
if (!pdb || !activeTxn)
return false;
int ret = activeTxn->abort();
activeTxn = NULL;
return (ret == 0);
}
bool ReadVersion(int& nVersion)
{
nVersion = 0;
return Read(std::string("version"), nVersion);
}
bool WriteVersion(int nVersion)
{
return Write(std::string("version"), nVersion);
}
bool static Rewrite(const std::string& strFile, const char* pszSkip = NULL);
};
#endif // CREDITS_WALLET_DB_H
| [
"[email protected]"
] | |
c350fe19bb50e00bc267f4949ce7b4836fad44bf | 5456502f97627278cbd6e16d002d50f1de3da7bb | /components/bookmarks/test/bookmark_test_helpers.cc | 79ed995a60aa6852278971e19954aa5d9cf54cc8 | [
"BSD-3-Clause"
] | permissive | TrellixVulnTeam/Chromium_7C66 | 72d108a413909eb3bd36c73a6c2f98de1573b6e5 | c8649ab2a0f5a747369ed50351209a42f59672ee | refs/heads/master | 2023-03-16T12:51:40.231959 | 2017-12-20T10:38:26 | 2017-12-20T10:38:26 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 4,832 | cc | // Copyright 2014 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "components/bookmarks/test/bookmark_test_helpers.h"
#include <stddef.h>
#include "base/callback.h"
#include "base/logging.h"
#include "base/macros.h"
#include "base/run_loop.h"
#include "base/strings/utf_string_conversions.h"
#include "components/bookmarks/browser/base_bookmark_model_observer.h"
#include "components/bookmarks/browser/bookmark_model.h"
#include "url/gurl.h"
namespace bookmarks {
namespace test {
namespace {
// BookmarkLoadObserver is used when blocking until the BookmarkModel finishes
// loading. As soon as the BookmarkModel finishes loading the message loop is
// quit.
class BookmarkLoadObserver : public BaseBookmarkModelObserver {
public:
explicit BookmarkLoadObserver(const base::Closure& quit_task);
~BookmarkLoadObserver() override;
private:
// BaseBookmarkModelObserver:
void BookmarkModelChanged() override;
void BookmarkModelLoaded(BookmarkModel* model, bool ids_reassigned) override;
base::Closure quit_task_;
DISALLOW_COPY_AND_ASSIGN(BookmarkLoadObserver);
};
BookmarkLoadObserver::BookmarkLoadObserver(const base::Closure& quit_task)
: quit_task_(quit_task) {}
BookmarkLoadObserver::~BookmarkLoadObserver() {}
void BookmarkLoadObserver::BookmarkModelChanged() {}
void BookmarkLoadObserver::BookmarkModelLoaded(BookmarkModel* model,
bool ids_reassigned) {
quit_task_.Run();
}
// Helper function which does the actual work of creating the nodes for
// a particular level in the hierarchy.
std::string::size_type AddNodesFromString(BookmarkModel* model,
const BookmarkNode* node,
const std::string& model_string,
std::string::size_type start_pos) {
DCHECK(node);
int index = node->child_count();
static const std::string folder_tell(":[");
std::string::size_type end_pos = model_string.find(' ', start_pos);
while (end_pos != std::string::npos) {
std::string::size_type part_length = end_pos - start_pos;
std::string node_name = model_string.substr(start_pos, part_length);
// Are we at the end of a folder group?
if (node_name != "]") {
// No, is it a folder?
std::string tell;
if (part_length > 2)
tell = node_name.substr(part_length - 2, 2);
if (tell == folder_tell) {
node_name = node_name.substr(0, part_length - 2);
const BookmarkNode* new_node =
model->AddFolder(node, index, base::UTF8ToUTF16(node_name));
end_pos = AddNodesFromString(model, new_node, model_string,
end_pos + 1);
} else {
std::string url_string("http://");
url_string += std::string(node_name.begin(), node_name.end());
url_string += ".com";
model->AddURL(
node, index, base::UTF8ToUTF16(node_name), GURL(url_string));
++end_pos;
}
++index;
start_pos = end_pos;
end_pos = model_string.find(' ', start_pos);
} else {
++end_pos;
break;
}
}
return end_pos;
}
} // namespace
void WaitForBookmarkModelToLoad(BookmarkModel* model) {
if (model->loaded())
return;
base::RunLoop run_loop;
base::MessageLoop::ScopedNestableTaskAllower allow(
base::MessageLoop::current());
BookmarkLoadObserver observer(run_loop.QuitClosure());
model->AddObserver(&observer);
run_loop.Run();
model->RemoveObserver(&observer);
DCHECK(model->loaded());
}
std::string ModelStringFromNode(const BookmarkNode* node) {
// Since the children of the node are not available as a vector,
// we'll just have to do it the hard way.
int child_count = node->child_count();
std::string child_string;
for (int i = 0; i < child_count; ++i) {
const BookmarkNode* child = node->GetChild(i);
if (child->is_folder()) {
child_string += base::UTF16ToUTF8(child->GetTitle()) + ":[ " +
ModelStringFromNode(child) + "] ";
} else {
child_string += base::UTF16ToUTF8(child->GetTitle()) + " ";
}
}
return child_string;
}
void AddNodesFromModelString(BookmarkModel* model,
const BookmarkNode* node,
const std::string& model_string) {
DCHECK(node);
std::string::size_type start_pos = 0;
std::string::size_type end_pos =
AddNodesFromString(model, node, model_string, start_pos);
DCHECK(end_pos == std::string::npos);
}
} // namespace test
} // namespace bookmarks
| [
"[email protected]"
] | |
ebf8d29e1e99fca55ad47155d0c3a25c85ba3f37 | 5efa31e47397234056e93f53be9263c26a617e0f | /Tutorial2 - Inheritance and Polymorphism/Tutorial2 - Inheritance and Polymorphism/Print.cpp | c259682e877c03cca6fbb7ed792429f52339ad5b | [] | no_license | Anish-Shrestha/OOP-Cplusplus | 663f0ef93ac46c87042c712a0b973b2d27fcc5fd | adf75b003e018e6a7139d760ba47809b8dbb7295 | refs/heads/master | 2021-01-12T10:23:30.167010 | 2016-12-15T08:14:41 | 2016-12-15T08:14:41 | 76,442,391 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 311 | cpp | #include "stdafx.h"
#include "Print.h"
Print::Print()
{
cout <<endl << "Default Constructor" << endl;
}
void Print::PringData(int data)
{
cout << "PrintData with int: " << data << endl;
}
void Print::PrintData(double data)
{
cout << "PrintData with double: " << data <<endl;
}
Print::~Print()
{
}
| [
"[email protected]"
] | |
b31ff315e28b872fdef4eb25e2d6307d836cb504 | 1a160fd0b4a96c85a3d5cc6c5a93b242e9cfda65 | /src/bip38.cpp | 37a1159a54e7186e9a67dbce774f35f9272135e9 | [
"MIT"
] | permissive | Alonewolf-123/AmbankCoin-Core | fc2bdf2e5a18264a8584ea71872f7383d3967fc0 | 76d6281eff342bb75827bb2b12768b1bd81dc14e | refs/heads/master | 2022-12-03T08:22:14.041666 | 2020-08-03T14:19:47 | 2020-08-03T14:19:47 | 282,668,150 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 10,445 | cpp | // Copyright (c) 2017-2019 The AMBANKCOIN developers
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
#include "bip38.h"
#include "base58.h"
#include "hash.h"
#include "pubkey.h"
#include "util.h"
#include "utilstrencodings.h"
#include "random.h"
#include <openssl/aes.h>
#include <secp256k1.h>
#include <string>
/** 39 bytes - 78 characters
* 1) Prefix - 2 bytes - 4 chars - strKey[0..3]
* 2) Flagbyte - 1 byte - 2 chars - strKey[4..5]
* 3) addresshash - 4 bytes - 8 chars - strKey[6..13]
* 4) Owner Entropy - 8 bytes - 16 chars - strKey[14..29]
* 5) Encrypted Part 1 - 8 bytes - 16 chars - strKey[30..45]
* 6) Encrypted Part 2 - 16 bytes - 32 chars - strKey[46..77]
*/
void DecryptAES(uint256 encryptedIn, uint256 decryptionKey, uint256& output)
{
AES_KEY key;
AES_set_decrypt_key(decryptionKey.begin(), 256, &key);
AES_decrypt(encryptedIn.begin(), output.begin(), &key);
}
void ComputePreFactor(std::string strPassphrase, std::string strSalt, uint256& prefactor)
{
//passfactor is the scrypt hash of passphrase and ownersalt (NOTE this needs to handle alt cases too in the future)
uint64_t s = uint256(ReverseEndianString(strSalt)).Get64();
scrypt_hash(strPassphrase.c_str(), strPassphrase.size(), BEGIN(s), strSalt.size() / 2, BEGIN(prefactor), 16384, 8, 8, 32);
}
void ComputePassfactor(std::string ownersalt, uint256 prefactor, uint256& passfactor)
{
//concat prefactor and ownersalt
uint512 temp(ReverseEndianString(HexStr(prefactor) + ownersalt));
Hash(temp.begin(), 40, passfactor.begin()); //40 bytes is the length of prefactor + salt
Hash(passfactor.begin(), 32, passfactor.begin());
}
bool ComputePasspoint(uint256 passfactor, CPubKey& passpoint)
{
size_t clen = 65;
secp256k1_context *ctx = secp256k1_context_create(SECP256K1_CONTEXT_SIGN);
assert(ctx != nullptr);
{
// Pass in a random blinding seed to the secp256k1 context.
std::vector<unsigned char, secure_allocator<unsigned char>> vseed(32);
GetRandBytes(vseed.data(), 32);
bool ret = secp256k1_context_randomize(ctx, vseed.data());
assert(ret);
}
secp256k1_pubkey pubkey;
//passpoint is the ec_mult of passfactor on secp256k1
if (!secp256k1_ec_pubkey_create(ctx, &pubkey, passfactor.begin())) {
secp256k1_context_destroy(ctx);
return false;
}
secp256k1_ec_pubkey_serialize(ctx, (unsigned char*)passpoint.begin(), &clen, &pubkey, SECP256K1_EC_COMPRESSED);
secp256k1_context_destroy(ctx);
if (passpoint.size() != clen)
return false;
if (!passpoint.IsValid())
return false;
return true;
}
void ComputeSeedBPass(CPubKey passpoint, std::string strAddressHash, std::string strOwnerSalt, uint512& seedBPass)
{
// Derive decryption key for seedb using scrypt with passpoint, addresshash, and ownerentropy
std::string salt = ReverseEndianString(strAddressHash + strOwnerSalt);
uint256 s2(salt);
scrypt_hash(BEGIN(passpoint), HexStr(passpoint).size() / 2, BEGIN(s2), salt.size() / 2, BEGIN(seedBPass), 1024, 1, 1, 64);
}
void ComputeFactorB(uint256 seedB, uint256& factorB)
{
//factorB - a double sha256 hash of seedb
Hash(seedB.begin(), 24, factorB.begin()); //seedB is only 24 bytes
Hash(factorB.begin(), 32, factorB.begin());
}
std::string AddressToBip38Hash(std::string address)
{
uint256 addrCheck;
Hash((void*)address.c_str(), address.size(), addrCheck.begin());
Hash(addrCheck.begin(), 32, addrCheck.begin());
return HexStr(addrCheck).substr(0, 8);
}
std::string BIP38_Encrypt(std::string strAddress, std::string strPassphrase, uint256 privKey, bool fCompressed)
{
std::string strAddressHash = AddressToBip38Hash(strAddress);
uint512 hashed;
uint64_t salt = uint256(ReverseEndianString(strAddressHash)).Get64();
scrypt_hash(strPassphrase.c_str(), strPassphrase.size(), BEGIN(salt), strAddressHash.size() / 2, BEGIN(hashed), 16384, 8, 8, 64);
uint256 derivedHalf1(hashed.ToString().substr(64, 64));
uint256 derivedHalf2(hashed.ToString().substr(0, 64));
//block1 = (pointb[1...16] xor derivedhalf1[0...15])
uint256 block1 = uint256((privKey << 128) ^ (derivedHalf1 << 128)) >> 128;
//encrypt part 1
uint512 encrypted1;
AES_KEY key;
AES_set_encrypt_key(derivedHalf2.begin(), 256, &key);
AES_encrypt(block1.begin(), encrypted1.begin(), &key);
//block2 = (pointb[17...32] xor derivedhalf1[16...31]
uint256 p2 = privKey >> 128;
uint256 dh12 = derivedHalf1 >> 128;
uint256 block2 = uint256(p2 ^ dh12);
//encrypt part 2
uint512 encrypted2;
AES_encrypt(block2.begin(), encrypted2.begin(), &key);
std::string strPrefix = "0142";
strPrefix += (fCompressed ? "E0" : "C0");
uint512 encryptedKey(ReverseEndianString(strPrefix + strAddressHash));
//add encrypted1 to the end of encryptedKey
encryptedKey = encryptedKey | (encrypted1 << 56);
//add encrypted2 to the end of encryptedKey
encryptedKey = encryptedKey | (encrypted2 << (56 + 128));
//Base58 checksum is the 4 bytes of dSHA256 hash of the encrypted key
uint256 hashChecksum = Hash(encryptedKey.begin(), encryptedKey.begin() + 39);
uint512 b58Checksum(hashChecksum.ToString().substr(64 - 8, 8));
// append the encrypted key with checksum (currently occupies 312 bits)
encryptedKey = encryptedKey | (b58Checksum << 312);
//43 bytes is the total size that we are encoding
return EncodeBase58(encryptedKey.begin(), encryptedKey.begin() + 43);
}
bool BIP38_Decrypt(std::string strPassphrase, std::string strEncryptedKey, uint256& privKey, bool& fCompressed)
{
std::string strKey = DecodeBase58(strEncryptedKey.c_str());
//incorrect encoding of key, it must be 39 bytes - and another 4 bytes for base58 checksum
if (strKey.size() != (78 + 8))
return false;
//invalid prefix
if (uint256(ReverseEndianString(strKey.substr(0, 2))) != uint256(0x01))
return false;
uint256 type(ReverseEndianString(strKey.substr(2, 2)));
uint256 flag(ReverseEndianString(strKey.substr(4, 2)));
std::string strAddressHash = strKey.substr(6, 8);
std::string ownersalt = strKey.substr(14, 16);
uint256 encryptedPart1(ReverseEndianString(strKey.substr(30, 16)));
uint256 encryptedPart2(ReverseEndianString(strKey.substr(46, 32)));
fCompressed = (flag & uint256(0x20)) != 0;
//not ec multiplied
if (type == uint256(0x42)) {
uint512 hashed;
encryptedPart1 = uint256(ReverseEndianString(strKey.substr(14, 32)));
uint64_t salt = uint256(ReverseEndianString(strAddressHash)).Get64();
scrypt_hash(strPassphrase.c_str(), strPassphrase.size(), BEGIN(salt), strAddressHash.size() / 2, BEGIN(hashed), 16384, 8, 8, 64);
uint256 derivedHalf1(hashed.ToString().substr(64, 64));
uint256 derivedHalf2(hashed.ToString().substr(0, 64));
uint256 decryptedPart1;
DecryptAES(encryptedPart1, derivedHalf2, decryptedPart1);
uint256 decryptedPart2;
DecryptAES(encryptedPart2, derivedHalf2, decryptedPart2);
//combine decrypted parts into 64 bytes
uint256 temp1 = decryptedPart2 << 128;
temp1 = temp1 | decryptedPart1;
//xor the decryption with the derived half 1 for the final key
privKey = temp1 ^ derivedHalf1;
return true;
} else if (type != uint256(0x43)) //invalid type
return false;
bool fLotSequence = (flag & 0x04) != 0;
std::string prefactorSalt = ownersalt;
if (fLotSequence)
prefactorSalt = ownersalt.substr(0, 8);
uint256 prefactor;
ComputePreFactor(strPassphrase, prefactorSalt, prefactor);
uint256 passfactor;
if (fLotSequence)
ComputePassfactor(ownersalt, prefactor, passfactor);
else
passfactor = prefactor;
CPubKey passpoint;
if (!ComputePasspoint(passfactor, passpoint))
return false;
uint512 seedBPass;
ComputeSeedBPass(passpoint, strAddressHash, ownersalt, seedBPass);
//get derived halfs, being mindful for endian switch
uint256 derivedHalf1(seedBPass.ToString().substr(64, 64));
uint256 derivedHalf2(seedBPass.ToString().substr(0, 64));
/** Decrypt encryptedpart2 using AES256Decrypt to yield the last 8 bytes of seedb and the last 8 bytes of encryptedpart1. **/
uint256 decryptedPart2;
DecryptAES(encryptedPart2, derivedHalf2, decryptedPart2);
//xor decryptedPart2 and 2nd half of derived half 1
uint256 x0 = derivedHalf1 >> 128; //drop off the first half (note: endian)
uint256 x1 = decryptedPart2 ^ x0;
uint256 seedbPart2 = x1 >> 64;
/** Decrypt encryptedpart1 to yield the remainder of seedb. **/
uint256 decryptedPart1;
uint256 x2 = x1 & uint256("0xffffffffffffffff"); // set x2 to seedbPart1 (still encrypted)
x2 = x2 << 64; //make room to add encryptedPart1 to the front
x2 = encryptedPart1 | x2; //combine with encryptedPart1
DecryptAES(x2, derivedHalf2, decryptedPart1);
//decrypted part 1: seedb[0..15] xor derivedhalf1[0..15]
uint256 x3 = derivedHalf1 & uint256("0xffffffffffffffffffffffffffffffff");
uint256 seedbPart1 = decryptedPart1 ^ x3;
uint256 seedB = seedbPart1 | (seedbPart2 << 128);
uint256 factorB;
ComputeFactorB(seedB, factorB);
//multiply passfactor by factorb mod N to yield the priv key
secp256k1_context *ctx = secp256k1_context_create(SECP256K1_CONTEXT_SIGN);
assert(ctx != nullptr);
{
// Pass in a random blinding seed to the secp256k1 context.
std::vector<unsigned char, secure_allocator<unsigned char>> vseed(32);
GetRandBytes(vseed.data(), 32);
bool ret = secp256k1_context_randomize(ctx, vseed.data());
assert(ret);
}
privKey = factorB;
if (!secp256k1_ec_privkey_tweak_mul(ctx, privKey.begin(), passfactor.begin())) {
secp256k1_context_destroy(ctx);
return false;
}
secp256k1_context_destroy(ctx);
//double check that the address hash matches our final privkey
CKey k;
k.Set(privKey.begin(), privKey.end(), fCompressed);
CPubKey pubkey = k.GetPubKey();
std::string address = CBitcoinAddress(pubkey.GetID()).ToString();
return strAddressHash == AddressToBip38Hash(address);
}
| [
"[email protected]"
] | |
0447869fd10a3c32926418d56b07787ba60f1a58 | 8a89f59302662db7021858157edf70aee974d68a | /source/fileUtils.h | ca3d04e18e0711befb6ac3ef63db64885013b70f | [] | no_license | Cydget/YAMM | fdb6060dee034795a1d6fdf4e45f136489da3c90 | c3bbd3adfc5a5436fb0a5a840faac515faf7d8cd | refs/heads/master | 2022-01-11T10:52:59.695667 | 2019-05-17T04:58:32 | 2019-05-17T04:58:32 | 186,272,683 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 542 | h | #pragma once
#ifndef fileUtils_H
#define fileUtils_H
#include <iostream>
#include <switch.h>
#include <string>
#include <string.h>//needed for c strlen
#include <zzip/lib.h>
#include <fstream>
#include <filesystem>
namespace sfs = std::filesystem;
void extractZip(std::string zipLocation,std::string outputFolderLocation);
void myRecCopy(std::string oldFolder,std::string newFolder);//until fs::filesystem::copy compiles on switch
void createDirectories(std::string folderPath);
void copyFile(std::string src, std::string dest);
#endif
| [
"[email protected]"
] | |
b283e46b7cf27ec5cdbd7c543325c17683b259f8 | 7ab669da18187a1b42858eab7f3255f8ed233f90 | /cuttingsqpaper.cpp | fe5e7ca05f29da7d5e1ef24be01670615b405b88 | [] | no_license | avani112/14DaysOfCode | 11373bfb8ea89307f307fc669a95ded56bc92f64 | 742ba5c0e78242884054c1f4cef0a9250f9df1e9 | refs/heads/master | 2021-07-13T14:51:46.544844 | 2020-10-10T14:54:30 | 2020-10-10T14:54:30 | 212,147,963 | 0 | 0 | null | 2020-10-10T14:54:31 | 2019-10-01T16:42:20 | Java | UTF-8 | C++ | false | false | 165 | cpp | #include <bits/stdc++.h>
using namespace std;
int main(){
long m, n;
cin>>n>>m;
long n1=n-1;
long m1=m-1;
long ways=m1+m*n1;
cout<<ways;
}
| [
"[email protected]"
] | |
2ec3304ffa4cf419e609abbdf900cbeca303f576 | ac9b294ed1b27504f1468ff0ac7a82eb982cf8d0 | /RadiationCorrections/AveragedUncOverlay.cpp | 9c2cd6a7c371d3924dfc895444e437767206dc37 | [] | no_license | afropapp13/e4nu | d8f1073d630745e61842587891ca5fd04bc6a5e8 | 8cb00a1ee852648ac8a7ac79cde461cb2217eca5 | refs/heads/master | 2023-06-24T23:37:21.926850 | 2022-03-02T17:09:12 | 2022-03-02T17:09:12 | 198,716,604 | 0 | 0 | null | 2019-07-24T22:15:24 | 2019-07-24T22:15:24 | null | UTF-8 | C++ | false | false | 9,743 | cpp | #include <TFile.h>
#include <TH1D.h>
#include <TF1.h>
#include <TCanvas.h>
#include <TString.h>
#include <TStyle.h>
#include <TLegend.h>
#include <TLegendEntry.h>
#include <TLatex.h>
#include <TMath.h>
#include <TLine.h>
#include <TPad.h>
#include <TGaxis.h>
#include <iostream>
#include <vector>
using namespace std;
#include "../myFunctions.cpp"
#include "../AfroConstants.h"
TGraph* RMSAveragedFunc(std::vector<TH1D*> hVec, TString Energy, TString Var) {
TH1D::SetDefaultSumw2();
// double DoubleE = -99., reso = 0.;
// if (Energy == "1_161") { DoubleE = 1.161; reso = 0.07; }
// if (Energy == "2_261") { DoubleE = 2.261; reso = 0.08; }
// if (Energy == "4_461") { DoubleE = 4.461; reso = 0.06; }
const int NBins = hVec[0]->GetXaxis()->GetNbins();
// ---------------------------------------------------------------------------------------------------------
// TH1D* RMSClone = (TH1D*)(hVec[0]->Clone("RMSClone"));
TString XaxisTitle = hVec[0]->GetXaxis()->GetTitle();
// RMSClone->Add(hVec[1],-1);
// RMSClone->Divide(h);
// RMSClone->Scale(1./TMath::Sqrt(12.));
// double sum = 0; int nbins = 0;
// for (int WhichBin = 1; WhichBin <= NBins; WhichBin++) {
// double BinCenter = RMSClone->GetBinCenter(WhichBin);
// double BinContent = RMSClone->GetBinContent(WhichBin);
// RMSClone->SetBinContent(WhichBin,BinContent);
//// if (BinCenter > (1-reso) * DoubleE && BinCenter < (1+reso) * DoubleE ) {
//// sum += BinContent; nbins++;
//// }
// }
//// sum = sum / double(nbins);
// ---------------------------------------------------------------------------------------------------------
double bincenter[NBins];
double binentry[NBins];
// // For Ecal only
// // Use the average around the Ecal peak in the bins (1 +/- reso) Ebeam
// if (Var == "epRecoEnergy_slice_0") {
// for (int WhichBin = 1; WhichBin <= NBins; WhichBin++) {
// double BinCenter = RMSClone->GetBinCenter(WhichBin);
// double BinContent = RMSClone->GetBinContent(WhichBin);
// if (BinCenter/DoubleE < 1.1) {
// bincenter[WhichBin-1] = BinCenter;
// if (BinCenter > (1-reso) * DoubleE && BinCenter < (1+reso) * DoubleE ) {
// RMSClone->SetBinContent(WhichBin,sum);
// binentry[WhichBin-1] = sum;
// } else { binentry[WhichBin-1] = BinContent; }
// }
// }
// } else {
for (int WhichBin = 1; WhichBin <= NBins; WhichBin++) {
double BinCenter = hVec[0]->GetBinCenter(WhichBin);
double BinContent = hVec[0]->GetBinContent(WhichBin);
bincenter[WhichBin-1] = BinCenter;
binentry[WhichBin-1] = BinContent;
}
// }
// ---------------------------------------------------------------------------------------------------------
TGraph* GraphClone = new TGraph(NBins,bincenter,binentry);
GraphClone->GetXaxis()->SetTitle(XaxisTitle);
// ---------------------------------------------------------------------------------------------------------
return GraphClone;
}
// ----------------------------------------------------------------------------------------------------------------
void AveragedUncOverlay() {
// ------------------------------------------------------------------------
GlobalSettings();
TH1D::SetDefaultSumw2();
const std::vector<int> Colors{kBlack,610,410,kRed+1,kCyan+1,kBlue,kOrange+1};
// ------------------------------------------------------------------------
std::vector<TString> xBCut;
std::vector<TString> nucleus;
std::vector<TString> LabelsOfSamples;
std::vector<TString> E;
std::vector<TString> LabelE;
std::vector<TString> FSIModel;
std::vector<TString> FSILabel;
std::vector<TString> NameOfPlots;
std::vector<TString> NameOfSubPlots;
nucleus.push_back("12C"); LabelsOfSamples.push_back("^{12}C");
nucleus.push_back("56Fe"); LabelsOfSamples.push_back("^{56}Fe");
nucleus.push_back("4He"); LabelsOfSamples.push_back("^{4}He");
E.push_back("1_161"); LabelE.push_back(", 1.1 GeV");
E.push_back("2_261"); LabelE.push_back(", 2.2 GeV");
E.push_back("4_461"); LabelE.push_back(", 4.4 GeV");
xBCut.push_back("NoxBCut");
// xBCut.push_back("xBCut");
FSIModel.push_back("SuSav2"); FSILabel.push_back("SuSav2");
// FSIModel.push_back("hA2018_Final"); FSILabel.push_back("G2018"); // Not to be used for acceptance correction
TString Var = "epRecoEnergy_slice_0";
// TString Var = "h_Erec_subtruct_piplpimi_noprot_3pi";
// TString Var = "MissMomentum";
// TString Var = "DeltaAlphaT_Int_0";
// TString Var = "DeltaPhiT_Int_0";
// NameOfPlots.push_back("Reco_eRecoEnergy_slice_0");
// NameOfPlots.push_back("TrueWithFid_eRecoEnergy_slice_0");
// NameOfPlots.push_back("True_eRecoEnergy_slice_0");
// NameOfPlots.push_back("BkgCorrection_eRecoEnergy_slice_0");
// NameOfPlots.push_back("FidCorrection_eRecoEnergy_slice_0");
// NameOfPlots.push_back("AccCorrection_eRecoEnergy_slice_0");
// NameOfPlots.push_back("Reco_epRecoEnergy_slice_0");
// NameOfPlots.push_back("TrueWithFid_epRecoEnergy_slice_0");
// NameOfPlots.push_back("True_epRecoEnergy_slice_0");
// NameOfPlots.push_back("AccCorrection_epRecoEnergy_slice_0");
// NameOfPlots.push_back("InverseAccCorrection_"+Var);
NameOfPlots.push_back("RadiationCorrection_"+Var);
// ------------------------------------------------------------------------
std::vector<TH1D*> Plots;
std::vector<TH1D*> average;
int NxBCuts = xBCut.size();
int NNuclei = nucleus.size();
int NEnergies = E.size();
int NFSIModels = FSIModel.size();
int NPlots = NameOfPlots.size();
// ------------------------------------------------------------------------
// Loop over the xB kinematics
for (int WhichxBCut = 0; WhichxBCut < NxBCuts; WhichxBCut ++) {
// Loop over the energies
for (int WhichEnergy = 0; WhichEnergy < NEnergies; WhichEnergy ++) {
TString NameCanvas = Var + "_" + xBCut[WhichxBCut] + "_" + E[WhichEnergy];
TCanvas* PlotCanvas = new TCanvas(NameCanvas,NameCanvas,205,34,1024,768);
PlotCanvas->SetLeftMargin(0.12);
PlotCanvas->SetBottomMargin(0.14);
// PlotCanvas->SetGridx();
// PlotCanvas->SetGridy();
int ColorCounter = 0;
average.clear();
TLegend* leg = new TLegend(0.13,0.78,0.87,0.87);
leg->SetNColumns(4);
leg->SetBorderSize(0);
leg->SetTextFont(132);
leg->SetTextSize(0.05);
leg->SetFillStyle(0);
// Loop over the nuclei
for (int WhichNucleus = 0; WhichNucleus < NNuclei; WhichNucleus ++) {
if (E[WhichEnergy] == "1_161" && nucleus[WhichNucleus] != "12C") { continue; }
// Loop over the plots
for (int WhichPlot = 0; WhichPlot < NPlots; WhichPlot ++) {
// ---------------------------------------------------------------------------------------
Plots.clear();
double max = -99.;
double min = 1E12;
// Loop over the FSI Models
for (int WhichFSIModel = 0; WhichFSIModel < NFSIModels; WhichFSIModel ++) {
TString FileName = "myFiles/Efficiency_"+FSIModel[WhichFSIModel]+"_"+nucleus[WhichNucleus]+"_"+E[WhichEnergy]+"_"+xBCut[WhichxBCut]+".root";
TFile* FileSample = TFile::Open(FileName);
Plots.push_back( (TH1D*)( FileSample->Get(FSIModel[WhichFSIModel]+"_"+NameOfPlots[WhichPlot]) ) );
Plots[WhichFSIModel]->SetLineColor(Colors[ColorCounter]);
} // End of the loop over the FSI Models
// average.push_back( (TH1D*)(Plots[0]->Clone()) );
// average[ColorCounter]->Add(Plots[1]);
// average[ColorCounter]->Scale(0.5);
std::vector<TH1D*> VectorPlots; VectorPlots.clear();
for (int i = 0; i < NFSIModels; i++) {
VectorPlots.push_back(Plots[i]);
}
TGraph* clone = RMSAveragedFunc(VectorPlots,E[WhichEnergy],Var);
ApplyRange(clone,E[WhichEnergy],Var);
// ---------------------------------------------------------------------------------------------------------------------
clone->GetXaxis()->SetTitleFont(132);
clone->GetXaxis()->SetLabelFont(132);
clone->GetXaxis()->SetTitleSize(0.05);
clone->GetXaxis()->SetLabelSize(0.05);
clone->GetXaxis()->SetLabelOffset(0.01);
clone->GetXaxis()->SetTitleOffset(1.2);
clone->GetXaxis()->CenterTitle();
clone->GetXaxis()->SetTickLength(0.01);
clone->GetXaxis()->SetNdivisions(8);
// ---------------------------------------------------------------------------------------------------------------------
clone->GetYaxis()->SetTitle("Radiation Correction");
clone->GetYaxis()->SetTitleFont(132);
clone->GetYaxis()->SetLabelFont(132);
clone->GetYaxis()->SetTitleSize(0.05);
clone->GetYaxis()->SetLabelSize(0.05);
clone->GetYaxis()->SetLabelOffset(0.01);
clone->GetYaxis()->CenterTitle();
clone->GetYaxis()->SetTickLength(0.01);
clone->GetYaxis()->SetNdivisions(10);
clone->GetYaxis()->SetRangeUser(0.5,1.5);
//if (E[WhichEnergy] == "1_161") { clone->GetYaxis()->SetRangeUser(-0.3,4.2); }
// ---------------------------------------------------------------------------------------------------------------------
clone->SetTitle("");
clone->SetMarkerStyle(20);
clone->SetMarkerSize(2.);
clone->SetMarkerColor(Colors[ColorCounter]);
if (ColorCounter == 0) { clone->Draw("ap"); }
else { clone->Draw("p"); }
TLegendEntry* l1 = leg->AddEntry(clone,nucleus[WhichNucleus] + LabelE[WhichEnergy], "");
l1->SetTextColor(Colors[ColorCounter]);
// -----------------------------------------------------------------------------------------------------------------------------------------
} // End of the loop over the plots
ColorCounter++;
} // End of the loop over the nuclei
leg->Draw();
PlotCanvas->SaveAs("RadCorr_"+NameCanvas+".pdf");
} // End of the loop over the energies
} // End of the loop over the xB kinematics
} // End of the program
| [
"[email protected]"
] | |
90043c485db5e2b228243bf2be2b00053bdc9202 | f45699e99d49143e49353f17b82d6e1135654f09 | /ComputerSimulation/ram.cc | eb82c1770ee84b1cad5b78f3b502df29f36859e4 | [] | no_license | Solmis/JNP1 | a6239ba011e0622eb8c1b42127dad736749bfa36 | 348c8ea31398a5d54a8964f003c96d6f8a16ba4c | refs/heads/master | 2016-09-03T06:25:02.826262 | 2015-04-28T22:37:47 | 2015-04-28T22:37:47 | 34,759,427 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 443 | cc | #include "exceptions.h"
#include "ram.h"
void RAM::setRAM(memory_type size)
{
if (size <= 0)
throw IllegalArgumentException();
else
{
sizeMemory = size;
memory.reset(new sys_type[size]);
}
}
memory_type RAM::size()
{
return sizeMemory;
}
sys_type RAM::read(memory_type number)
{
return memory[number];
}
void RAM::write(memory_type number, sys_type value)
{
memory[number] = value;
} | [
"[email protected]"
] | |
dba1f275769fc2590efcb453b6ca361c8154d777 | 26fab765811902f2d75da694eed687eca2121919 | /code/kernels/common/subdiv/subdivpatch1base.cpp | 016c19b143d9e0d4e731207bffec488da6c90211 | [
"Apache-2.0"
] | permissive | embree/embree-benchmark | 236b00b0f03c466669e3b2591f2a47b38af08671 | b4ea57d9ea24d6036795257c67a4b2b13757e9f3 | refs/heads/master | 2021-01-12T03:18:11.894210 | 2019-10-31T07:34:26 | 2019-10-31T07:34:26 | 81,297,588 | 4 | 2 | null | null | null | null | UTF-8 | C++ | false | false | 12,214 | cpp | // ======================================================================== //
// Copyright 2009-2015 Intel Corporation //
// //
// Licensed under the Apache License, Version 2.0 (the "License"); //
// you may not use this file except in compliance with the License. //
// You may obtain a copy of the License at //
// //
// http://www.apache.org/licenses/LICENSE-2.0 //
// //
// Unless required by applicable law or agreed to in writing, software //
// distributed under the License is distributed on an "AS IS" BASIS, //
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. //
// See the License for the specific language governing permissions and //
// limitations under the License. //
// ======================================================================== //
#include "../scene_subdiv_mesh.h"
#include "subdivpatch1base.h"
#include "../scene.h"
namespace embree
{
__forceinline Vec3fa computeInnerBezierControlPoint(const Vec3fa v[4][4], const size_t y, const size_t x)
{
return 1.0f / 36.0f * (16.0f * v[y][x] + 4.0f * (v[y-1][x] + v[y+1][x] + v[y][x-1] + v[y][x+1]) + (v[y-1][x-1] + v[y+1][x+1] + v[y-1][x+1] + v[y+1][x-1]));
}
__forceinline Vec3fa computeTopEdgeBezierControlPoint(const Vec3fa v[4][4], const size_t y, const size_t x)
{
return 1.0f / 18.0f * (8.0f * v[y][x] + 4.0f * v[y-1][x] + 2.0f * (v[y][x-1] + v[y][x+1]) + (v[y-1][x-1] + v[y-1][x+1]));
}
__forceinline Vec3fa computeButtomEdgeBezierControlPoint(const Vec3fa v[4][4], const size_t y, const size_t x)
{
return 1.0f / 18.0f * (8.0f * v[y][x] + 4.0f * v[y+1][x] + 2.0f * (v[y][x-1] + v[y][x+1]) + v[y+1][x-1] + v[y+1][x+1]);
}
__forceinline Vec3fa computeLeftEdgeBezierControlPoint(const Vec3fa v[4][4], const size_t y, const size_t x)
{
return 1.0f / 18.0f * (8.0f * v[y][x] + 4.0f * v[y][x-1] + 2.0f * (v[y-1][x] + v[y+1][x]) + v[y-1][x-1] + v[y+1][x-1]);
}
__forceinline Vec3fa computeRightEdgeBezierControlPoint(const Vec3fa v[4][4], const size_t y, const size_t x)
{
return 1.0f / 18.0f * (8.0f * v[y][x] + 4.0f * v[y][x+1] + 2.0f * (v[y-1][x] + v[y+1][x]) + v[y-1][x+1] + v[y+1][x+1]);
}
__forceinline Vec3fa computeCornerBezierControlPoint(const Vec3fa v[4][4], const size_t y, const size_t x, const ssize_t delta_y, const ssize_t delta_x)
{
return 1.0f / 9.0f * (4.0f * v[y][x] + 2.0f * (v[y+delta_y][x] + v[y][x+delta_x]) + v[y+delta_y][x+delta_x]);
}
void convertToBicubicBezierPatch(const Vec3fa source[4][4],
Vec3fa dest[4][4])
{
/* compute inner bezier control points */
dest[0][0] = computeInnerBezierControlPoint(source,1,1);
dest[0][3] = computeInnerBezierControlPoint(source,1,2);
dest[3][3] = computeInnerBezierControlPoint(source,2,2);
dest[3][0] = computeInnerBezierControlPoint(source,2,1);
/* compute top edge control points */
dest[0][1] = computeRightEdgeBezierControlPoint(source,1,1);
dest[0][2] = computeLeftEdgeBezierControlPoint(source,1,2);
/* compute buttom edge control points */
dest[3][1] = computeRightEdgeBezierControlPoint(source,2,1);
dest[3][2] = computeLeftEdgeBezierControlPoint(source,2,2);
/* compute left edge control points */
dest[1][0] = computeButtomEdgeBezierControlPoint(source,1,1);
dest[2][0] = computeTopEdgeBezierControlPoint(source,2,1);
/* compute right edge control points */
dest[1][3] = computeButtomEdgeBezierControlPoint(source,1,2);
dest[2][3] = computeTopEdgeBezierControlPoint(source,2,2);
/* compute corner control points */
dest[1][1] = computeCornerBezierControlPoint(source,1,1, 1, 1);
dest[1][2] = computeCornerBezierControlPoint(source,1,2, 1,-1);
dest[2][2] = computeCornerBezierControlPoint(source,2,2,-1,-1);
dest[2][1] = computeCornerBezierControlPoint(source,2,1,-1, 1);
}
/*! Construction from vertices and IDs. */
SubdivPatch1Base::SubdivPatch1Base (const CatmullClarkPatch3fa& ipatch,
const int fas_depth,
const unsigned int gID,
const unsigned int pID,
const SubdivMesh *const mesh,
const Vec2f uv[4],
const float edge_level[4],
const int neighborSubdiv[4],
const BezierCurve3fa *border,
const int border_flags)
: geom(gID),prim(pID),flags(0)
{
static_assert(sizeof(SubdivPatch1Base) == 5 * 64, "SubdivPatch1Base has wrong size");
mtx.reset();
for (size_t i=0; i<4; i++) {
u[i] = (unsigned short)(uv[i].x * 65535.0f);
v[i] = (unsigned short)(uv[i].y * 65535.0f);
}
updateEdgeLevels(edge_level,mesh);
/* determine whether patch is regular or not */
if (fas_depth == 0 && ipatch.isRegular1() && !ipatch.hasBorder()) /* only select b-spline/bezier in the interior and not FAS-based patches*/
{
#if 0
/* bezier */
BSplinePatch3fa tmp;
tmp.init( ipatch );
convertToBicubicBezierPatch(tmp.v,patch.v);
flags |= BEZIER_PATCH;
#else
/* bspline */
flags |= BSPLINE_PATCH;
patch.init( ipatch );
#endif
}
else
{
/* gregory patches */
flags |= GREGORY_PATCH;
GregoryPatch3fa gpatch;
gpatch.init_crackfix( ipatch, fas_depth, neighborSubdiv, border, border_flags );
gpatch.exportDenseConrolPoints( patch.v );
}
}
void SubdivPatch1Base::updateEdgeLevels(const float edge_level[4],const SubdivMesh *const mesh)
{
/* init discrete edge tessellation levels and grid resolution */
assert( edge_level[0] >= 0.0f );
assert( edge_level[1] >= 0.0f );
assert( edge_level[2] >= 0.0f );
assert( edge_level[3] >= 0.0f );
#if defined(__MIC__)
const size_t SIMD_WIDTH = 16;
#else
const size_t SIMD_WIDTH = 8;
#endif
level[0] = max(ceilf(edge_level[0]),1.0f);
level[1] = max(ceilf(edge_level[1]),1.0f);
level[2] = max(ceilf(edge_level[2]),1.0f);
level[3] = max(ceilf(edge_level[3]),1.0f);
grid_u_res = max(level[0],level[2])+1; // n segments -> n+1 points
grid_v_res = max(level[1],level[3])+1;
/* workaround for 2x2 intersection stencil */
#if !defined(__MIC__)
grid_u_res = max(grid_u_res,3);
grid_v_res = max(grid_v_res,3);
#endif
#if defined(__MIC__)
grid_size_simd_blocks = ((grid_u_res*grid_v_res+15)&(-16)) / 16;
grid_subtree_size_64b_blocks = 5; // single leaf with u,v,x,y,z
#else
/* 8-wide SIMD is default on Xeon */
grid_size_simd_blocks = ((grid_u_res*grid_v_res+7)&(-8)) / 8;
grid_subtree_size_64b_blocks = (sizeof(Quad2x2)+63) / 64; // single Quad2x2
#endif
/* need stiching? */
flags &= ~TRANSITION_PATCH;
const unsigned int int_edge_points0 = (unsigned int)level[0] + 1;
const unsigned int int_edge_points1 = (unsigned int)level[1] + 1;
const unsigned int int_edge_points2 = (unsigned int)level[2] + 1;
const unsigned int int_edge_points3 = (unsigned int)level[3] + 1;
if (int_edge_points0 < (unsigned int)grid_u_res ||
int_edge_points2 < (unsigned int)grid_u_res ||
int_edge_points1 < (unsigned int)grid_v_res ||
int_edge_points3 < (unsigned int)grid_v_res)
flags |= TRANSITION_PATCH;
/* tessellate into grid blocks for larger grid resolutions, generate bvh4 subtree over grid blocks*/
#if defined(__MIC__)
const size_t leafBlocks = 4;
#else
const size_t leafBlocks = (sizeof(Quad2x2)+63) / 64;
#endif
grid_bvh_size_64b_blocks = getSubTreeSize64bBlocks( 0 );
const size_t grid_size_xyzuv = (grid_size_simd_blocks * SIMD_WIDTH) * 4;
grid_subtree_size_64b_blocks = grid_bvh_size_64b_blocks + ((grid_size_xyzuv+15) / 16);
/* has displacements? */
flags &= ~HAS_DISPLACEMENT;
if (mesh->displFunc != nullptr)
flags |= HAS_DISPLACEMENT;
}
void SubdivPatch1Base::evalToOBJ(Scene *scene,size_t &vertex_index, size_t &numTotalTriangles)
{
#if defined(__MIC__)
THROW_RUNTIME_ERROR("EVALTOOBJ NOT SUPPORTED ON MIC");
#else
#if !defined(_MSC_VER) || defined(__INTEL_COMPILER)
__aligned(64) float grid_x[(grid_size_simd_blocks+1)*8];
__aligned(64) float grid_y[(grid_size_simd_blocks+1)*8];
__aligned(64) float grid_z[(grid_size_simd_blocks+1)*8];
__aligned(64) float grid_u[(grid_size_simd_blocks+1)*8];
__aligned(64) float grid_v[(grid_size_simd_blocks+1)*8];
__aligned(64) float grid_nx[(grid_size_simd_blocks+1)*8];
__aligned(64) float grid_ny[(grid_size_simd_blocks+1)*8];
__aligned(64) float grid_nz[(grid_size_simd_blocks+1)*8];
#else
const size_t array_elements = (grid_size_simd_blocks + 1) * 8;
float *const ptr = (float*)_malloca(8 * array_elements * sizeof(float) + 64);
float *const grid_arrays = (float*)ALIGN_PTR(ptr,64);
float *grid_x = &grid_arrays[array_elements * 0];
float *grid_y = &grid_arrays[array_elements * 1];
float *grid_z = &grid_arrays[array_elements * 2];
float *grid_u = &grid_arrays[array_elements * 3];
float *grid_v = &grid_arrays[array_elements * 4];
float *grid_nx = &grid_arrays[array_elements * 5];
float *grid_ny = &grid_arrays[array_elements * 6];
float *grid_nz = &grid_arrays[array_elements * 7];
#endif
SubdivMesh *mesh = (SubdivMesh *)scene->getSubdivMesh(geom);
evalGrid(*this,grid_x,grid_y,grid_z,grid_u,grid_v,mesh);
#if defined(__AVX__)
for (size_t i=0;i<grid_size_simd_blocks;i++)
{
float8 uu = load8f(&grid_u[8*i]);
float8 vv = load8f(&grid_v[8*i]);
Vec3f8 normal = normalize(patch.normal(uu,vv));
*(float8*)&grid_nx[8*i] = normal.x;
*(float8*)&grid_ny[8*i] = normal.y;
*(float8*)&grid_nz[8*i] = normal.z;
}
#else
for (size_t i=0;i<grid_size_simd_blocks*2;i++) // 4-wide blocks for SSE
{
float4 uu = load4f(&grid_u[4*i]);
float4 vv = load4f(&grid_v[4*i]);
Vec3f4 normal = normalize(patch.normal(uu,vv));
*(float4*)&grid_nx[4*i] = normal.x;
*(float4*)&grid_ny[4*i] = normal.y;
*(float4*)&grid_nz[4*i] = normal.z;
}
#endif
std::cout << "# grid_u_res " << grid_u_res << std::endl;
std::cout << "# grid_v_res " << grid_v_res << std::endl;
/* vertex */
for (size_t v=0;v<grid_v_res;v++)
for (size_t u=0;u<grid_u_res;u++)
{
size_t offset = v * grid_u_res + u;
std::cout << "v " << grid_x[offset] << " " << grid_y[offset] << " " << grid_z[offset] << std::endl;
}
/* normal */
for (size_t v=0;v<grid_v_res;v++)
for (size_t u=0;u<grid_u_res;u++)
{
size_t offset = v * grid_u_res + u;
std::cout << "vn " << grid_nx[offset] << " " << grid_ny[offset] << " " << grid_nz[offset] << std::endl;
}
for (size_t v=0;v<grid_v_res-1;v++)
for (size_t u=0;u<grid_u_res-1;u++)
{
size_t offset0 = vertex_index + v * grid_u_res + u;
size_t offset1 = offset0 + grid_u_res;
//std::cout << "f " << offset0+1 << " " << offset0+2 << " " << offset1+2 << " " << offset1+1 << std::endl;
std::cout << "f " << offset0+1 << "//" << offset0+1 << " " << offset0+2<< "//" << offset0+2 << " " << offset1+2<< "//" << offset1+2 << " " << offset1+1<< "//" << offset1+1 << std::endl;
numTotalTriangles += 2;
}
vertex_index += grid_u_res*grid_v_res;
#if defined(_MSC_VER) && !defined(__INTEL_COMPILER)
_freea(ptr);
#endif
#endif
}
}
| [
"[email protected]"
] | |
0af5da2c4cbb9f8db50fe211031f6f4246729577 | b0dd7779c225971e71ae12c1093dc75ed9889921 | /libs/heap/test/common_heap_tests.hpp | 802e561f7f351c7dd2ad7cad73de925a77ca170c | [
"LicenseRef-scancode-warranty-disclaimer",
"BSL-1.0"
] | permissive | blackberry/Boost | 6e653cd91a7806855a162347a5aeebd2a8c055a2 | fc90c3fde129c62565c023f091eddc4a7ed9902b | refs/heads/1_48_0-gnu | 2021-01-15T14:31:33.706351 | 2013-06-25T16:02:41 | 2013-06-25T16:02:41 | 2,599,411 | 244 | 154 | BSL-1.0 | 2018-10-13T18:35:09 | 2011-10-18T14:25:18 | C++ | UTF-8 | C++ | false | false | 10,549 | hpp | #ifndef COMMON_HEAP_TESTS_HPP_INCLUDED
#define COMMON_HEAP_TESTS_HPP_INCLUDED
#include <algorithm>
#include <vector>
#include <boost/concept/assert.hpp>
#include <boost/concept_archetype.hpp>
#include <boost/heap/heap_concepts.hpp>
typedef boost::default_constructible_archetype<
boost::less_than_comparable_archetype<
boost::copy_constructible_archetype<
boost::assignable_archetype<
> > > > test_value_type;
typedef std::vector<int> test_data;
const int test_size = 64;//128;
struct dummy_run
{
static void run(void)
{}
};
test_data make_test_data(int size, int offset = 0, int strive = 1)
{
test_data ret;
for (int i = 0; i != size; ++i)
ret.push_back(i * strive + offset);
return ret;
}
template <typename pri_queue, typename data_container>
void check_q(pri_queue & q, data_container const & expected)
{
BOOST_REQUIRE_EQUAL(q.size(), expected.size());
for (unsigned int i = 0; i != expected.size(); ++i)
{
BOOST_REQUIRE_EQUAL(q.size(), expected.size() - i);
BOOST_REQUIRE_EQUAL(q.top(), expected[expected.size()-1-i]);
q.pop();
}
BOOST_REQUIRE(q.empty());
}
template <typename pri_queue, typename data_container>
void fill_q(pri_queue & q, data_container const & data)
{
for (unsigned int i = 0; i != data.size(); ++i)
q.push(data[i]);
}
#if defined(BOOST_HAS_RVALUE_REFS) && !defined(BOOST_NO_VARIADIC_TEMPLATES)
template <typename pri_queue, typename data_container>
void fill_emplace_q(pri_queue & q, data_container const & data)
{
for (unsigned int i = 0; i != data.size(); ++i) {
typename pri_queue::value_type value = data[i];
q.emplace(std::move(value));
}
}
#endif
template <typename pri_queue>
void pri_queue_test_sequential_push(void)
{
for (int i = 0; i != test_size; ++i)
{
pri_queue q;
test_data data = make_test_data(i);
fill_q(q, data);
check_q(q, data);
}
}
template <typename pri_queue>
void pri_queue_test_sequential_reverse_push(void)
{
for (int i = 0; i != test_size; ++i)
{
pri_queue q;
test_data data = make_test_data(i);
std::reverse(data.begin(), data.end());
fill_q(q, data);
std::reverse(data.begin(), data.end());
check_q(q, data);
}
}
template <typename pri_queue>
void pri_queue_test_emplace(void)
{
#if defined(BOOST_HAS_RVALUE_REFS) && !defined(BOOST_NO_VARIADIC_TEMPLATES)
for (int i = 0; i != test_size; ++i)
{
pri_queue q;
test_data data = make_test_data(i);
std::reverse(data.begin(), data.end());
fill_emplace_q(q, data);
std::reverse(data.begin(), data.end());
check_q(q, data);
}
#endif
}
template <typename pri_queue>
void pri_queue_test_random_push(void)
{
for (int i = 0; i != test_size; ++i)
{
pri_queue q;
test_data data = make_test_data(i);
test_data shuffled (data);
std::random_shuffle(shuffled.begin(), shuffled.end());
fill_q(q, shuffled);
check_q(q, data);
}
}
template <typename pri_queue>
void pri_queue_test_copyconstructor(void)
{
for (int i = 0; i != test_size; ++i)
{
pri_queue q;
test_data data = make_test_data(i);
fill_q(q, data);
pri_queue r(q);
check_q(r, data);
}
}
template <typename pri_queue>
void pri_queue_test_assignment(void)
{
for (int i = 0; i != test_size; ++i)
{
pri_queue q;
test_data data = make_test_data(i);
fill_q(q, data);
pri_queue r;
r = q;
check_q(r, data);
}
}
template <typename pri_queue>
void pri_queue_test_moveconstructor(void)
{
#ifdef BOOST_HAS_RVALUE_REFS
pri_queue q;
test_data data = make_test_data(test_size);
fill_q(q, data);
pri_queue r(std::move(q));
check_q(r, data);
BOOST_REQUIRE(q.empty());
#endif
}
template <typename pri_queue>
void pri_queue_test_move_assignment(void)
{
#ifdef BOOST_HAS_RVALUE_REFS
pri_queue q;
test_data data = make_test_data(test_size);
fill_q(q, data);
pri_queue r;
r = std::move(q);
check_q(r, data);
BOOST_REQUIRE(q.empty());
#endif
}
template <typename pri_queue>
void pri_queue_test_swap(void)
{
for (int i = 0; i != test_size; ++i)
{
pri_queue q;
test_data data = make_test_data(i);
test_data shuffled (data);
std::random_shuffle(shuffled.begin(), shuffled.end());
fill_q(q, shuffled);
pri_queue r;
q.swap(r);
check_q(r, data);
BOOST_REQUIRE(q.empty());
}
}
template <typename pri_queue>
void pri_queue_test_iterators(void)
{
for (int i = 0; i != test_size; ++i) {
test_data data = make_test_data(test_size);
test_data shuffled (data);
std::random_shuffle(shuffled.begin(), shuffled.end());
pri_queue q;
BOOST_REQUIRE(q.begin() == q.end());
fill_q(q, shuffled);
for (unsigned long i = 0; i != data.size(); ++i)
BOOST_REQUIRE(std::find(q.begin(), q.end(), data[i]) != q.end());
for (unsigned long i = 0; i != data.size(); ++i)
BOOST_REQUIRE(std::find(q.begin(), q.end(), data[i] + data.size()) == q.end());
test_data data_from_queue(q.begin(), q.end());
std::sort(data_from_queue.begin(), data_from_queue.end());
BOOST_REQUIRE(data == data_from_queue);
for (unsigned long i = 0; i != data.size(); ++i) {
BOOST_REQUIRE_EQUAL((long)std::distance(q.begin(), q.end()), (long)(data.size() - i));
q.pop();
}
}
}
template <typename pri_queue>
void pri_queue_test_ordered_iterators(void)
{
for (int i = 0; i != test_size; ++i) {
test_data data = make_test_data(i);
test_data shuffled (data);
std::random_shuffle(shuffled.begin(), shuffled.end());
pri_queue q;
BOOST_REQUIRE(q.ordered_begin() == q.ordered_end());
fill_q(q, shuffled);
test_data data_from_queue(q.ordered_begin(), q.ordered_end());
std::reverse(data_from_queue.begin(), data_from_queue.end());
BOOST_REQUIRE(data == data_from_queue);
for (unsigned long i = 0; i != data.size(); ++i)
BOOST_REQUIRE(std::find(q.ordered_begin(), q.ordered_end(), data[i]) != q.ordered_end());
for (unsigned long i = 0; i != data.size(); ++i)
BOOST_REQUIRE(std::find(q.ordered_begin(), q.ordered_end(), data[i] + data.size()) == q.ordered_end());
for (unsigned long i = 0; i != data.size(); ++i) {
BOOST_REQUIRE_EQUAL((long)std::distance(q.begin(), q.end()), (long)(data.size() - i));
q.pop();
}
}
}
template <typename pri_queue>
void pri_queue_test_equality(void)
{
for (int i = 0; i != test_size; ++i)
{
pri_queue q, r;
test_data data = make_test_data(i);
fill_q(q, data);
std::reverse(data.begin(), data.end());
fill_q(r, data);
BOOST_REQUIRE(r == q);
}
}
template <typename pri_queue>
void pri_queue_test_inequality(void)
{
for (int i = 1; i != test_size; ++i)
{
pri_queue q, r;
test_data data = make_test_data(i);
fill_q(q, data);
data[0] = data.back() + 1;
fill_q(r, data);
BOOST_REQUIRE(r != q);
}
}
template <typename pri_queue>
void pri_queue_test_less(void)
{
for (int i = 1; i != test_size; ++i)
{
pri_queue q, r;
test_data data = make_test_data(i);
test_data r_data(data);
r_data.pop_back();
fill_q(q, data);
fill_q(r, r_data);
BOOST_REQUIRE(r < q);
}
for (int i = 1; i != test_size; ++i)
{
pri_queue q, r;
test_data data = make_test_data(i);
test_data r_data(data);
data.push_back(data.back() + 1);
fill_q(q, data);
fill_q(r, r_data);
BOOST_REQUIRE(r < q);
}
for (int i = 1; i != test_size; ++i)
{
pri_queue q, r;
test_data data = make_test_data(i);
test_data r_data(data);
data.back() += 1;
fill_q(q, data);
fill_q(r, r_data);
BOOST_REQUIRE(r < q);
}
for (int i = 1; i != test_size; ++i)
{
pri_queue q, r;
test_data data = make_test_data(i);
test_data r_data(data);
r_data.front() -= 1;
fill_q(q, data);
fill_q(r, r_data);
BOOST_REQUIRE(r < q);
}
}
template <typename pri_queue>
void pri_queue_test_clear(void)
{
for (int i = 0; i != test_size; ++i)
{
pri_queue q;
test_data data = make_test_data(i);
fill_q(q, data);
q.clear();
BOOST_REQUIRE(q.size() == 0);
BOOST_REQUIRE(q.empty());
}
}
template <typename pri_queue>
void run_concept_check(void)
{
BOOST_CONCEPT_ASSERT((boost::heap::PriorityQueue<pri_queue>));
}
template <typename pri_queue>
void run_common_heap_tests(void)
{
pri_queue_test_sequential_push<pri_queue>();
pri_queue_test_sequential_reverse_push<pri_queue>();
pri_queue_test_random_push<pri_queue>();
pri_queue_test_equality<pri_queue>();
pri_queue_test_inequality<pri_queue>();
pri_queue_test_less<pri_queue>();
pri_queue_test_clear<pri_queue>();
pri_queue_test_emplace<pri_queue>();
}
template <typename pri_queue>
void run_iterator_heap_tests(void)
{
pri_queue_test_iterators<pri_queue>();
}
template <typename pri_queue>
void run_copyable_heap_tests(void)
{
pri_queue_test_copyconstructor <pri_queue>();
pri_queue_test_assignment<pri_queue>();
pri_queue_test_swap<pri_queue>();
}
template <typename pri_queue>
void run_moveable_heap_tests(void)
{
pri_queue_test_moveconstructor <pri_queue>();
pri_queue_test_move_assignment <pri_queue>();
}
template <typename pri_queue>
void run_reserve_heap_tests(void)
{
test_data data = make_test_data(test_size);
pri_queue q;
q.reserve(6);
fill_q(q, data);
check_q(q, data);
}
#endif // COMMON_HEAP_TESTS_HPP_INCLUDED
| [
"[email protected]"
] | |
345d4dad78879f44706f8d8ab0b44d45e391c54c | 42e44907236e391dc6f0cc20909446ea032756db | /src/ibeo_8l_sdk/src/ibeosdk/datablocks/snippets/ContourPoint.cpp | d45dbe6b593417904b638b680af70f7876815e68 | [
"MIT"
] | permissive | tomcamp0228/ibeo_ros2 | dd840f8500d3a0ec72861d22b5d5469d50a957b9 | ff56c88d6e82440ae3ce4de08f2745707c354604 | refs/heads/master | 2022-11-24T18:11:30.630072 | 2020-07-27T06:15:41 | 2020-07-27T06:15:41 | 272,166,535 | 1 | 2 | null | 2020-06-26T07:38:38 | 2020-06-14T09:00:30 | C++ | UTF-8 | C++ | false | false | 3,385 | cpp | //======================================================================
/*! \file ContourPoint.cpp
*
* \copydoc Copyright
* \author Jan Christian Dittmer (jcd)
* \date Apr 23, 2014
*///-------------------------------------------------------------------
//======================================================================
#include <ibeosdk/datablocks/snippets/ContourPoint.hpp>
#include <ibeosdk/io.hpp>
#include <iostream>
//======================================================================
namespace ibeosdk {
//======================================================================
ContourPoint::ContourPoint()
: m_posX(0),
m_posY(0),
m_posXSigma(0),
m_posYSigma(0),
m_corrCoeff(0),
m_existenceProbability(0)
{}
//======================================================================
ContourPoint::ContourPoint(const Point2d pt)
: m_posX(pt.getX()),
m_posY(pt.getY()),
m_posXSigma(0),
m_posYSigma(0),
m_corrCoeff(0),
m_existenceProbability(0)
{}
//======================================================================
ContourPoint::~ContourPoint() {}
//======================================================================
bool ContourPoint::deserialize(std::istream& is)
{
const std::istream::pos_type startPos = is.tellg();
ibeosdk::readBE(is, m_posX);
ibeosdk::readBE(is, m_posY);
ibeosdk::readBE(is, m_posXSigma);
ibeosdk::readBE(is, m_posYSigma);
ibeosdk::readBE(is, m_corrCoeff);
ibeosdk::readBE(is, m_existenceProbability);
return !is.fail() && ((is.tellg() - startPos) == this->getSerializedSize());
}
//======================================================================
bool ContourPoint::serialize(std::ostream& os) const
{
const std::istream::pos_type startPos = os.tellp();
ibeosdk::writeBE(os, m_posX);
ibeosdk::writeBE(os, m_posY);
ibeosdk::writeBE(os, m_posXSigma);
ibeosdk::writeBE(os, m_posYSigma);
ibeosdk::writeBE(os, m_corrCoeff);
ibeosdk::writeBE(os, m_existenceProbability);
return !os.fail() && ((os.tellp() - startPos) == this->getSerializedSize());
}
//======================================================================
//======================================================================
//======================================================================
bool operator==(const ContourPoint& lhs, const ContourPoint& rhs)
{
if (lhs.getX() != rhs.getX()) return false;
if (lhs.getY() != rhs.getY()) return false;
if (lhs.getXSigma() != rhs.getXSigma()) return false;
if (lhs.getYSigma() != rhs.getYSigma()) return false;
if (lhs.getCorrCoeff() != rhs.getCorrCoeff()) return false;
if (lhs.getExistenceProbability() != rhs.getExistenceProbability()) return false;
return true;
}
//======================================================================
bool operator!=(const ContourPoint& lhs, const ContourPoint& rhs)
{
if (lhs.getX() != rhs.getX()) return true;
if (lhs.getY() != rhs.getY()) return true;
if (lhs.getXSigma() != rhs.getXSigma()) return true;
if (lhs.getYSigma() != rhs.getYSigma()) return true;
if (lhs.getCorrCoeff() != rhs.getCorrCoeff()) return true;
if (lhs.getExistenceProbability() != rhs.getExistenceProbability()) return true;
return false;
}
//======================================================================
}// namespace ibeosdk
//======================================================================
| [
"[email protected]"
] | |
54bf06c64ff4fa6398c549d74fdc817ca504d606 | 068d67cd80e71a2288b50e7bbedae67a520f301a | /linked list/deldouble.cpp | 7f087ad8d0e37e2fe11b00e58dd709fe65aa7248 | [] | no_license | aadamsaleem/Data-Structures-Using-C | 9bad6748c6d814768c427eecd91e6838eae57875 | 19d8b385bcd5d985167ce90944b54b51b56fe79e | refs/heads/master | 2016-08-12T08:30:38.643660 | 2016-02-13T22:29:33 | 2016-02-13T22:29:33 | 51,667,994 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,004 | cpp | /* Deletion in Doubly linklist */
/* Data Structures Using C by UDIT AGARWAL */
# include <stdio.h>
# include <conio.h>
# include <alloc.h>
struct node
{
int info;
struct node *lpt;
struct node *rpt;
};
struct node *first;
void main ( )
{
clrscr();
void create ( );
void ftraverse ( );
void delete_beg ( );
void delete_end ( );
void delete_given_node ( );
create ( );
ftraverse ( );
delete_beg ( );
printf(" \n Doubly linklist after DELETION at beginning: \n");
ftraverse ( );
delete_end ( );
printf(" \n Doubly linklist after DELETION at end: \n");
ftraverse ( );
delete_given_node ( );
ftraverse ( );
getch ( );
}
void create ( )
{
struct node *ptr, *cpt;
char ch;
ptr = (struct node *) malloc (sizeof (struct node));
printf ("\n Input first node information");
scanf ("%d", & ptr -> info);
ptr -> lpt = NULL;
first = ptr;
do
{
cpt = (struct node *) malloc (sizeof (struct node));
printf ("\nInput next node :\n");
scanf ("%d", & cpt -> info);
ptr -> rpt = cpt;
cpt -> lpt = ptr;
ptr = cpt;
printf ("Press <Y/N> for more node \n");
ch = getche ( );
}
while (ch== 'Y');
ptr -> rpt = NULL;
}
void ftraverse ( )
{
struct node *ptr;
printf ("Traversing of linklist is:\n");
ptr = first;
while (ptr != NULL)
{
printf ("%d \n", ptr -> info);
ptr = ptr -> rpt;
}
}
void delete_beg ( )
{
struct node *ptr;
if(first == NULL)
{
printf ("Underflow\n");
return;
}
ptr=first;
first = ptr -> rpt;
first -> lpt = NULL;
free(ptr);
}
void delete_end ( )
{
struct node *ptr, *cpt;
if (first == NULL)
{
printf ("Underflow\n");
return;
}
ptr = first;
while (ptr -> rpt!= NULL)
{
cpt = ptr;
ptr = ptr -> rpt;
}
cpt -> rpt = NULL;
free (ptr);
printf ("Deletion is done\n");
}
void delete_given_node ( )
{
struct node *ptr, *cpt, *tpt;
int m;
if(first == NULL)
{
printf ("Underflow");
return;
}
printf ("\n Node to be deleted is");
scanf ("%d", &m);
ptr = first;
while (ptr -> info != m)
ptr = ptr -> rpt;
cpt = ptr -> lpt;
tpt = ptr -> rpt;
cpt -> rpt = tpt;
tpt -> lpt = cpt;
free (ptr);
printf ("Deletion is done\n");
} | [
"[email protected]"
] | |
fcb048526477735774a06e57a923de792948747b | 024c74f395b4a749b26cf2719b1e4efecd5331fc | /Codeforces/159C.cpp | 69ec733ef3217717d31641d980f4258e9742d577 | [] | no_license | thisisrajat/competitive-programming | 28ed70f77e2c3892ee1d005341ef7d37930caad9 | 422cc7fac78a9908ca7a95a7c6eae724ed4a0631 | refs/heads/master | 2021-01-01T18:12:10.693796 | 2017-01-01T17:42:53 | 2017-01-01T17:42:53 | 17,668,936 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,372 | cpp | #include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
#include <vector>
#include <list>
#include <string>
#include <map>
#include <set>
#include <deque>
#include <sstream>
#include <utility>
#include <functional>
#include <numeric>
#include <stack>
#include <queue>
#include <climits>
#include <cmath>
#include <cstdlib>
#include <iomanip>
#include <ctime>
#include <memory.h>
#include <cassert>
using namespace std;
#define d(b) cout << #b << " " << b << endl;
int main() {
int k;
scanf("%d", &k);
vector < vector <int> > val (k+10, vector<int> (30, 0));
string keeper[k+10];
string s, ss;
cin >> s;
for(int i = 0; i < k; i++) {
ss += s;
keeper[i] = s;
}
for(int i = 0; i < s.size(); i++) {
for(int j = 0; j < k; j++) {
val[j][s[i] - 'a']++;
}
}
int n;
scanf("%d", &n);
while(n--) {
char ch; int nn;
scanf("%d %c", &nn, &ch);
int ip = 0;
while(val[ip][ch - 'a'] < nn) {
nn -= val[ip][ch - 'a'];
ip++;
}
int idx;
// d(nn);
for(int i = 0; i < keeper[ip].size(); i++) {
if(keeper[ip][i] == ch) {
if(nn == 1) {
idx = i;
}
nn--;
}
}
// d(idx);
val[ip][ch - 'a']--;
keeper[ip].erase(keeper[ip].begin()+idx);
}
for(int i = 0; i < k; i++) {
cout << keeper[i];
}
cout << endl;
} | [
"[email protected]"
] | |
51cd2b6c7147eb43cc17c9cae02ce047fc7b0ff9 | 337460599cd8ee0f5fd1b02e62fbc0c693b32f4a | /chrome/browser/ui/toolbar/toolbar_actions_model.h | 3264895a77bdea41adce87b59f0c5ace71b1199f | [
"BSD-3-Clause"
] | permissive | LarryAChen/chromium | 8e34c84b5f809cdd5c24156510af6537062d8526 | f4635897f69d67dbf4ecd0f08f62633b92de2d7a | refs/heads/master | 2023-02-28T08:33:08.834920 | 2019-07-11T14:20:29 | 2019-07-11T14:20:29 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 13,896 | h | // Copyright (c) 2012 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef CHROME_BROWSER_UI_TOOLBAR_TOOLBAR_ACTIONS_MODEL_H_
#define CHROME_BROWSER_UI_TOOLBAR_TOOLBAR_ACTIONS_MODEL_H_
#include <stddef.h>
#include <vector>
#include "base/compiler_specific.h"
#include "base/macros.h"
#include "base/observer_list.h"
#include "base/scoped_observer.h"
#include "chrome/browser/extensions/api/extension_action/extension_action_api.h"
#include "chrome/browser/extensions/extension_action.h"
#include "chrome/browser/extensions/load_error_reporter.h"
#include "components/keyed_service/core/keyed_service.h"
#include "components/prefs/pref_change_registrar.h"
#include "extensions/browser/extension_prefs.h"
#include "extensions/browser/extension_registry_observer.h"
#include "extensions/common/extension.h"
class Browser;
class PrefService;
class Profile;
class ExtensionsContainer;
class ToolbarActionViewController;
namespace extensions {
class ExtensionActionManager;
class ExtensionMessageBubbleController;
class ExtensionRegistry;
} // namespace extensions
// Model for the browser actions toolbar. This is a per-profile instance, and
// manages the user's global preferences.
// Each browser window will attempt to show browser actions as specified by this
// model, but if the window is too narrow, actions may end up pushed into the
// overflow menu on a per-window basis. Callers interested in the arrangement of
// actions in a particular window should check that window's instance of
// ExtensionsContainer, which is responsible for the per-window layout.
class ToolbarActionsModel : public extensions::ExtensionActionAPI::Observer,
public extensions::LoadErrorReporter::Observer,
public extensions::ExtensionRegistryObserver,
public KeyedService {
public:
using ActionId = std::string;
// The different options for highlighting.
enum HighlightType {
HIGHLIGHT_NONE,
HIGHLIGHT_WARNING,
};
ToolbarActionsModel(Profile* profile,
extensions::ExtensionPrefs* extension_prefs);
~ToolbarActionsModel() override;
// A class which is informed of changes to the model; represents the view of
// MVC. Also used for signaling view changes such as showing extension popups.
// TODO(devlin): Should this really be an observer? It acts more like a
// delegate.
class Observer {
public:
// Signals that |id| has been added to the toolbar at |index|. This will
// *only* be called after the toolbar model has been initialized.
virtual void OnToolbarActionAdded(const ActionId& id, int index) = 0;
// Signals that the given action with |id| has been removed from the
// toolbar.
virtual void OnToolbarActionRemoved(const ActionId& id) = 0;
// Signals that the given action with |id| has been moved to |index|.
// |index| is the desired *final* index of the action (that is, in the
// adjusted order, action should be at |index|).
virtual void OnToolbarActionMoved(const ActionId& id, int index) = 0;
// Signals that the extension, corresponding to the toolbar action, has
// failed to load.
virtual void OnToolbarActionLoadFailed() = 0;
// Signals that the browser action with |id| has been updated.
virtual void OnToolbarActionUpdated(const ActionId& id) = 0;
// Signals when the container needs to be redrawn because of a size change,
// and when the model has finished loading.
virtual void OnToolbarVisibleCountChanged() = 0;
// Signals that the model has entered or exited highlighting mode, or that
// the actions being highlighted have (probably*) changed. Highlighting
// mode indicates that only a subset of the toolbar actions are actively
// displayed, and those actions should be highlighted for extra emphasis.
// * probably, because if we are in highlight mode and receive a call to
// highlight a new set of actions, we do not compare the current set with
// the new set (and just assume the new set is different).
virtual void OnToolbarHighlightModeChanged(bool is_highlighting) = 0;
// Signals that the toolbar model has been initialized, so that if any
// observers were postponing animation during the initialization stage, they
// can catch up.
virtual void OnToolbarModelInitialized() = 0;
// Called whenever the pinned actions change.
virtual void OnToolbarPinnedActionsChanged() = 0;
protected:
virtual ~Observer() {}
};
// Convenience function to get the ToolbarActionsModel for a Profile.
static ToolbarActionsModel* Get(Profile* profile);
// Adds or removes an observer.
void AddObserver(Observer* observer);
void RemoveObserver(Observer* observer);
// Moves the given action with |id|'s icon to the given |index|.
void MoveActionIcon(const ActionId& id, size_t index);
// Sets the number of action icons that should be visible.
// If count == size(), this will set the visible icon count to -1, meaning
// "show all actions".
void SetVisibleIconCount(size_t count);
// Note that this (and all_icons_visible()) are the global default, but are
// inappropriate for determining a specific window's state - for that, use
// the ToolbarActionsBar.
size_t visible_icon_count() const {
// We have guards around this because |visible_icon_count_| can be set by
// prefs/sync, and we want to ensure that the icon count returned is within
// bounds.
return visible_icon_count_ == -1
? action_ids().size()
: std::min(static_cast<size_t>(visible_icon_count_),
action_ids().size());
}
bool all_icons_visible() const {
return visible_icon_count() == action_ids().size();
}
bool actions_initialized() const { return actions_initialized_; }
std::vector<std::unique_ptr<ToolbarActionViewController>> CreateActions(
Browser* browser,
ExtensionsContainer* main_bar,
bool in_overflow_menu);
std::unique_ptr<ToolbarActionViewController> CreateActionForId(
Browser* browser,
ExtensionsContainer* main_bar,
bool in_overflow_menu,
const ActionId& action_id);
const std::vector<ActionId>& action_ids() const {
return is_highlighting() ? highlighted_action_ids_ : action_ids_;
}
bool is_highlighting() const { return highlight_type_ != HIGHLIGHT_NONE; }
HighlightType highlight_type() const { return highlight_type_; }
bool has_active_bubble() const { return has_active_bubble_; }
void set_has_active_bubble(bool has_active_bubble) {
has_active_bubble_ = has_active_bubble;
}
void SetActionVisibility(const ActionId& action_id, bool visible);
void OnActionToolbarPrefChange();
// Highlights the actions specified by |action_ids|. This will cause
// the LocationBarModel to only display those actions.
// Highlighting mode is only entered if there is at least one action to be
// shown.
// Returns true if highlighting mode is entered, false otherwise.
bool HighlightActions(const std::vector<ActionId>& action_ids,
HighlightType type);
// Stop highlighting actions. All actions can be shown again, and the
// number of visible icons will be reset to what it was before highlighting.
void StopHighlighting();
// Gets the ExtensionMessageBubbleController that should be shown for this
// profile, if any.
std::unique_ptr<extensions::ExtensionMessageBubbleController>
GetExtensionMessageBubbleController(Browser* browser);
// Returns true if the action is pinned to the toolbar.
bool IsActionPinned(const ActionId& action_id) const;
// Returns the ordered list of ids of pinned actions.
const std::vector<ActionId>& pinned_action_ids() const {
return pinned_action_ids_;
}
private:
// Callback when actions are ready.
void OnReady();
// ExtensionRegistryObserver:
void OnExtensionLoaded(content::BrowserContext* browser_context,
const extensions::Extension* extension) override;
void OnExtensionUnloaded(content::BrowserContext* browser_context,
const extensions::Extension* extension,
extensions::UnloadedExtensionReason reason) override;
void OnExtensionUninstalled(content::BrowserContext* browser_context,
const extensions::Extension* extension,
extensions::UninstallReason reason) override;
// ExtensionActionAPI::Observer:
void OnExtensionActionUpdated(
ExtensionAction* extension_action,
content::WebContents* web_contents,
content::BrowserContext* browser_context) override;
// extensions::LoadErrorReporter::Observer:
void OnLoadFailure(content::BrowserContext* browser_context,
const base::FilePath& extension_path,
const std::string& error) override;
// To be called after the extension service is ready; gets loaded extensions
// from the ExtensionRegistry, their saved order from the pref service, and
// constructs |action_ids_| from these data. IncognitoPopulate() takes
// the shortcut - looking at the regular model's content and modifying it.
void InitializeActionList();
void Populate();
void IncognitoPopulate();
// Save the model to prefs.
void UpdatePrefs();
// Removes any preference for |action_id| and saves the model to prefs.
void RemovePref(const ActionId& action_id);
// Finds the last known visible position of the icon for |action|. The value
// returned is a zero-based index into the vector of visible actions.
size_t FindNewPositionFromLastKnownGood(const ActionId& action_id);
// Returns true if the given |extension| should be added to the toolbar.
bool ShouldAddExtension(const extensions::Extension* extension);
// Adds or removes the given |extension| from the toolbar model.
void AddExtension(const extensions::Extension* extension);
void RemoveExtension(const extensions::Extension* extension);
// Returns true if |action_id| is in the toolbar model.
bool HasAction(const ActionId& action_id) const;
// Adds |action_id| to the toolbar. If the action has an existing preference
// for toolbar position, that will be used to determine its location.
// Otherwise it will be placed at the end of the visible actions. If the
// toolbar is in highlighting mode, the action will not be visible until
// highlighting mode is exited.
void AddAction(const ActionId& action_id);
// Removes |action_id| from the toolbar. If the toolbar is in highlighting
// mode, the action is also removed from the highlighted list (if present).
void RemoveAction(const ActionId& action_id);
// Looks up and returns the extension with the given |id| in the set of
// enabled extensions.
const extensions::Extension* GetExtensionById(const ActionId& id) const;
// Returns true if the action is visible on the toolbar.
bool IsActionVisible(const ActionId& action_id) const;
// Gets a list of pinned action ids that only contains that only contains IDs
// with a corresponding action in the model.
std::vector<ActionId> GetFilteredPinnedActionIds() const;
// Our observers.
base::ObserverList<Observer>::Unchecked observers_;
// The Profile this toolbar model is for.
Profile* profile_;
extensions::ExtensionPrefs* extension_prefs_;
PrefService* prefs_;
// The ExtensionActionAPI object, cached for convenience.
extensions::ExtensionActionAPI* extension_action_api_;
// The ExtensionRegistry object, cached for convenience.
extensions::ExtensionRegistry* extension_registry_;
// The ExtensionActionManager, cached for convenience.
extensions::ExtensionActionManager* extension_action_manager_;
// True if we've handled the initial EXTENSIONS_READY notification.
bool actions_initialized_;
// Ordered list of browser action IDs.
std::vector<ActionId> action_ids_;
// List of browser action IDs which should be highlighted.
std::vector<ActionId> highlighted_action_ids_;
// Set of pinned action IDs.
std::vector<ActionId> pinned_action_ids_;
// The current type of highlight (with HIGHLIGHT_NONE indicating no current
// highlight).
HighlightType highlight_type_;
// A list of action ids ordered to correspond with their last known
// positions.
std::vector<ActionId> last_known_positions_;
// The number of icons visible (the rest should be hidden in the overflow
// chevron). A value of -1 indicates that all icons should be visible.
// Instead of using this variable directly, use visible_icon_count() if
// possible.
// TODO(devlin): Make a new variable to indicate that all icons should be
// visible, instead of overloading this one.
int visible_icon_count_;
// Whether or not there is an active ExtensionMessageBubbleController
// associated with the profile. There should only be one at a time.
bool has_active_bubble_;
ScopedObserver<extensions::ExtensionActionAPI,
extensions::ExtensionActionAPI::Observer>
extension_action_observer_;
// Listen to extension load, unloaded notifications.
ScopedObserver<extensions::ExtensionRegistry, ExtensionRegistryObserver>
extension_registry_observer_;
// For observing change of toolbar order preference by external entity (sync).
PrefChangeRegistrar pref_change_registrar_;
base::Closure pref_change_callback_;
ScopedObserver<extensions::LoadErrorReporter,
extensions::LoadErrorReporter::Observer>
load_error_reporter_observer_;
base::WeakPtrFactory<ToolbarActionsModel> weak_ptr_factory_;
DISALLOW_COPY_AND_ASSIGN(ToolbarActionsModel);
};
#endif // CHROME_BROWSER_UI_TOOLBAR_TOOLBAR_ACTIONS_MODEL_H_
| [
"[email protected]"
] | |
89e473036c29ee124613c345f6622e4b764659b1 | 113c7cebf0a4d25039fc92f6f2eda3aaa9563e9e | /translatorController/driveController.cpp | f9de128cd3148f64e7836bf899fcea5b076b174d | [] | no_license | Woocheck/Wheeled_robot | 581c8d869cb56338bf4b9473ecf193ec9358ff29 | 6b5be5d83b4d79af26824eefec579d66723a372b | refs/heads/master | 2020-04-29T00:13:32.399066 | 2019-10-23T18:49:18 | 2019-10-23T18:49:18 | 175,686,163 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,375 | cpp | #include <unistd.h>
#include <utility>
#include "./driveController.h"
void DriveController::timer_handler(int signum)
{
if( isMoveOrdered_ )
moveNextStep();
}
bool DriveController::isTimeToNextStep()
{
auto isTime = isTimeToClaculateNextStep_;
isTimeToClaculateNextStep_ = false;
return isTime;
}
void DriveController::move( int dist, int ang )
{
distance_ = dist;
angle_ = ang;
rightEncoder_.resetNumberOfPulses();
leftEncoder_.resetNumberOfPulses();
isMoveOrdered_ = true;
}
std::pair<int,int> DriveController::calculateNextStep()
{
static int previousErrorTranslation { 0 };
static int previousErrorRotation { 0 };
int currentErrorTranslation;
int currentErrorRotation;
[ currentErrorTranslation, currentErrorRotation ] = calculateCurrentError();
auto regulatorNewPwmLeft = translationRegulator_.calculate(
currentErrorTranslation ,
currentErrorTranslation - previousErrorTranslation )
+ rotationRegulator_.calculate(
currentErrorRotation ,
currentErrorRotation - previousErrorRotation );
auto regulatorNewPwmRight = translationRegulator_.calculate(
currentErrorTranslation ,
currentErrorTranslation - previousErrorTranslation )
- rotationRegulator_.calculate(
currentErrorRotation ,
currentErrorRotation - previousErrorRotation );
previousErrorTranslation = currentErrorTranslation;
previousErrorRotation = currentErrorRotation;
return std::make_pair( static_cast<int>( regulatorNewPwmLeft ),
static_cast<int>( regulatorNewPwmRight ) );
}
void DriveController::moveNextStep()
{
int leftPWM;
int rightPWM;
[ leftPWM, rightPWM ] = calculateNextStep();
drive_.driveControll( leftPWM, rightPWM );
}
std::pair<int,int> DriveController::calculateCurrentError()
{
int translation = distance_ - ( leftEncoder_.getNumeberOfPulses
+ rightEncoder_.getNumeberOfPulses );
int rotation = angle_ - ( leftEncoder_.getNumeberOfPulses
- rightEncoder_.getNumeberOfPulses );
return std::make_pair<int, int>( translation, rotation );
}
| [
"[email protected]"
] | |
d30ff933efdd56b41461a1cc3f55547232156c80 | 8d8d34d5e6779e20fb53e6a32144f72e5c36bca7 | /Vertex.cpp | 870c31a2b3c665675b8d567ee8c3d600ab06798b | [] | no_license | user576g/GraphEditor | 55a0e9a2abd49047624e05b78a8f113f177cb7d6 | ff8c781bbb5817ffb87f744b3e4841e9a42cfd60 | refs/heads/master | 2022-11-28T04:03:35.958536 | 2020-08-06T19:51:14 | 2020-08-06T19:51:14 | 259,123,907 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,236 | cpp | #include "Vertex.h"
#include "Logic.h"
#include "Windows.h"
#include "WindowParameters.h"
void Vertex::draw(HDC hdc) {
WindowParameters* window = WindowParameters::getInstance();
HBRUSH prevBrush = (HBRUSH) SelectObject(hdc, window->colors.vertexBkrg);
Logic::drawCircle(hdc, center.x, center.y);
int radius = window->radiusForVertex;
int halfSmallerSquare = radius / sqrt(2);
RECT square = {
center.x - halfSmallerSquare, center.y - halfSmallerSquare,
center.x + halfSmallerSquare, center.y + halfSmallerSquare
};
if (1 == name.size()) {
Logic::drawBigLetter(hdc, square, name[0]);
}
else {
DrawText(hdc, name.c_str(), -1, &square, DT_SINGLELINE |
DT_CENTER | DT_VCENTER | DT_MODIFYSTRING | DT_END_ELLIPSIS);
}
SelectObject(hdc, prevBrush);
}
Vertex::Vertex(int num, POINT p) {
if (num < 0) {
// write to Logger
}
number = num;
center = p;
char buf[] = "X";
buf[0] = 65 + number;
name = std::string(buf);
}
Vertex::Vertex(char* s, POINT p, int n) {
number = n;
center = p;
name = std::string(s);
}
POINT Vertex::getCenter() {
return center;
}
Vertex::Vertex(){
number = 0;
center = {0, 0};
}
void Vertex::setCenter(POINT p) {
center = p;
} | [
"[email protected]"
] | |
8896190e9b2a8d7f46faae0e14366a337efedbb6 | 7f5920a044b8f0f858558305b3da693182037245 | /lbf-pbrt/src/materials/matte.h | 175d35809faed250e0764e2f432d57e0da9757b2 | [] | no_license | jehutymax/lbf-mitsuba | 5f43b5fdae322f73b9eddd1bad11095b2c4f6b3d | 8d891f616a1c77d453e8ff3aa5d6bdab5267aba6 | refs/heads/master | 2021-01-10T09:01:56.206525 | 2015-12-09T21:47:51 | 2015-12-09T21:47:51 | 47,661,605 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,528 | h |
/*
pbrt source code Copyright(c) 1998-2012 Matt Pharr and Greg Humphreys.
This file is part of pbrt.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are
met:
- Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
- Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#if defined(_MSC_VER)
#pragma once
#endif
#ifndef PBRT_MATERIALS_MATTE_H
#define PBRT_MATERIALS_MATTE_H
// materials/matte.h*
#include "pbrt.h"
#include "material.h"
// MatteMaterial Declarations
class MatteMaterial : public Material {
public:
// MatteMaterial Public Methods
MatteMaterial(Reference<Texture<Spectrum> > kd,
Reference<Texture<float> > sig,
Reference<Texture<float> > bump)
: Kd(kd), sigma(sig), bumpMap(bump) {
}
BSDF *GetBSDF(const DifferentialGeometry &dgGeom,
const DifferentialGeometry &dgShading,
MemoryArena &arena, int bounceNum, bool isSpecularBounce = false, bool saveTexture2 = false, float rWeight = 1.0f, float gWeight = 1.0f, float bWeight = 1.0f) const;
float getReflectanceProb() {
return -1.0f;
}
private:
// MatteMaterial Private Data
Reference<Texture<Spectrum> > Kd;
Reference<Texture<float> > sigma, bumpMap;
};
MatteMaterial *CreateMatteMaterial(const Transform &xform,
const TextureParams &mp);
#endif // PBRT_MATERIALS_MATTE_H
| [
"[email protected]"
] | |
2d5b51233686fc7b25e303099789ddb419eb4592 | 235f766d0edadf581ff6bec0d8fffa181655207b | /data/maps/secludedforest/scripts.inc | 011a4c2be0ce6c0e54ef7b75bf2bcc5ef7941f5f | [] | no_license | lassellie/pokeemeraldexceptglitched | ff0f179048bf11cf653c4567b97c31d748a8102e | 39d0bedabe7f4d42dac1b5297c6961ca39a6763a | refs/heads/master | 2023-06-07T19:29:46.645077 | 2021-06-30T04:30:47 | 2021-06-30T04:30:47 | 267,154,726 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 37 | inc | secludedforest_MapScripts::
.byte 0
| [
"[email protected]"
] | |
eac6e8512436e5741e3d9a57a03baa54b42bfb53 | 422714b7f72325bcf84ba3fc91b177ca431e46cd | /core/conversion/converters/Weights.cpp | 7e0519cc5086ceae19eb3bcda822f0e15f82ff70 | [
"BSD-2-Clause",
"BSD-3-Clause"
] | permissive | abhi-iyer/TRTorch | 05da755dd4fcfb356da9795c363cffe1a75aa14e | ab3de3cdca22e9e80a19c42d42e620dc53af5ca3 | refs/heads/master | 2022-12-14T08:00:38.808080 | 2020-07-28T21:15:40 | 2020-07-28T21:15:40 | 268,927,120 | 1 | 0 | BSD-3-Clause | 2020-06-02T23:14:31 | 2020-06-02T23:08:10 | null | UTF-8 | C++ | false | false | 3,419 | cpp | #include "core/util/prelude.h"
#include "core/conversion/converters/Weights.h"
namespace trtorch {
namespace core {
namespace conversion {
namespace converters {
Weights::Weights() {
this->num_input_maps = 0;
this->num_output_maps = 0;
this->data.type = nvinfer1::DataType::kFLOAT;
this->data.values = nullptr;
this->data.count = 0;
}
Weights::Weights(ConversionCtx* ctx, float val) {
this->num_input_maps = 1;
this->num_output_maps = 1;
this->data.type = nvinfer1::DataType::kFLOAT;
float* buf = reinterpret_cast<float*>(malloc(1 * sizeof(float)));
buf[0] = val;
this->data.values = buf;
this->data.count = 1;
ctx->builder_resources.push_back(buf);
this->shape.nbDims = 0;
this->kernel_shape.nbDims = 0;
}
Weights::Weights(ConversionCtx* ctx, int32_t val) {
this->num_input_maps = 1;
this->num_output_maps = 1;
this->data.type = nvinfer1::DataType::kINT32;
int32_t* buf = reinterpret_cast<int32_t*>(malloc(1 * sizeof(int32_t)));
buf[0] = val;
this->data.values = buf;
this->data.count = 1;
ctx->builder_resources.push_back(buf);
this->shape.nbDims = 0;
this->kernel_shape.nbDims = 0;
}
Weights::Weights(ConversionCtx* ctx, at::Tensor t) {
if (t.sizes().size() > nvinfer1::Dims::MAX_DIMS) {
TRTORCH_THROW_ERROR("The tensor requested to be converted to nvinfer1::Weights exceeds the max number of dimensions for TensorRT");
}
this->shape = util::toDims(t.sizes());
if (t.sizes().size() >= 2) {
// Linear and Conv2/3D
this->num_input_maps = t.sizes()[1];
this->num_output_maps = t.sizes()[0];
} else {
// Bias
this->num_input_maps = t.sizes()[0];
this->num_output_maps = t.sizes()[0];
}
if (t.sizes().size() > 2) {
this->kernel_shape.nbDims = t.sizes().size() - 2;
for (size_t i = 2; i < t.sizes().size(); i++) {
this->kernel_shape.d[i - 2] = t.sizes()[i];
this->data.count *= this->kernel_shape.d[i - 2];
}
} else {
this->kernel_shape.nbDims = 1;
this->kernel_shape.d[0] = 1;
}
auto t_cpu = t.to(at::kCPU);
t_cpu = t_cpu.contiguous();
auto dtype_optional = util::toTRTDataType(t_cpu.dtype());
if (!dtype_optional) {
TRTORCH_THROW_ERROR("The tensor requested to be converted to nvinfer1::Weights is of an unsupported type");
}
// Store the data in the conversion context so it remains until building is complete
void* buf = malloc(t_cpu.numel() * sizeof(float));
ctx->builder_resources.push_back(buf);
memcpy(buf, t_cpu.data_ptr(), t_cpu.numel() * sizeof(float));
this->data.type = dtype_optional.value();
this->data.count = t_cpu.numel();
this->data.values = buf;
LOG_DEBUG(*this);
}
std::ostream& operator<<(std::ostream& os, const Weights& w) {
os << "Weights: " << w.shape \
<< "\n Number of input maps: " << w.num_input_maps \
<< "\n Number of output maps: " << w.num_output_maps \
<< "\n Element shape: [";
for (int i = 0; i < w.kernel_shape.nbDims; i++) {
os << w.kernel_shape.d[i];
if (i + 1 < w.kernel_shape.nbDims) {
os << ',';
}
}
os << ']';
return os;
}
} // namespace converters
} // namespace conversion
} // namespace core
} // namespace trtorch
| [
"[email protected]"
] | |
bbe797e9fa200de0e9044ca1609caf9f03fc4319 | 88ae8695987ada722184307301e221e1ba3cc2fa | /cc/layers/scrollbar_layer_unittest.cc | c78687df04fc5646bcb8e8050c543fb9b463222a | [
"BSD-3-Clause"
] | permissive | iridium-browser/iridium-browser | 71d9c5ff76e014e6900b825f67389ab0ccd01329 | 5ee297f53dc7f8e70183031cff62f37b0f19d25f | refs/heads/master | 2023-08-03T16:44:16.844552 | 2023-07-20T15:17:00 | 2023-07-23T16:09:30 | 220,016,632 | 341 | 40 | BSD-3-Clause | 2021-08-13T13:54:45 | 2019-11-06T14:32:31 | null | UTF-8 | C++ | false | false | 62,788 | cc | // Copyright 2012 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include <stddef.h>
#include <memory>
#include <unordered_map>
#include "base/memory/raw_ptr.h"
#include "base/task/single_thread_task_runner.h"
#include "cc/animation/animation_host.h"
#include "cc/input/scrollbar_animation_controller.h"
#include "cc/layers/append_quads_data.h"
#include "cc/layers/painted_overlay_scrollbar_layer.h"
#include "cc/layers/painted_scrollbar_layer.h"
#include "cc/layers/painted_scrollbar_layer_impl.h"
#include "cc/layers/scrollbar_layer_base.h"
#include "cc/layers/solid_color_scrollbar_layer.h"
#include "cc/layers/solid_color_scrollbar_layer_impl.h"
#include "cc/resources/ui_resource_manager.h"
#include "cc/test/fake_impl_task_runner_provider.h"
#include "cc/test/fake_layer_tree_host.h"
#include "cc/test/fake_layer_tree_host_client.h"
#include "cc/test/fake_layer_tree_host_impl.h"
#include "cc/test/fake_painted_scrollbar_layer.h"
#include "cc/test/fake_scrollbar.h"
#include "cc/test/layer_tree_impl_test_base.h"
#include "cc/test/layer_tree_test.h"
#include "cc/test/mock_occlusion_tracker.h"
#include "cc/test/stub_layer_tree_host_single_thread_client.h"
#include "cc/test/test_task_graph_runner.h"
#include "cc/trees/effect_node.h"
#include "cc/trees/layer_tree_host.h"
#include "cc/trees/layer_tree_impl.h"
#include "cc/trees/occlusion_tracker.h"
#include "cc/trees/scroll_node.h"
#include "cc/trees/single_thread_proxy.h"
#include "cc/trees/tree_synchronizer.h"
#include "components/viz/common/quads/solid_color_draw_quad.h"
#include "components/viz/test/test_context_provider.h"
#include "components/viz/test/test_gles2_interface.h"
#include "testing/gmock/include/gmock/gmock.h"
#include "testing/gtest/include/gtest/gtest.h"
namespace cc {
class FakeResourceTrackingUIResourceManager : public UIResourceManager {
public:
FakeResourceTrackingUIResourceManager()
: next_id_(1),
total_ui_resource_created_(0),
total_ui_resource_deleted_(0) {}
~FakeResourceTrackingUIResourceManager() override = default;
UIResourceId CreateUIResource(UIResourceClient* content) override {
total_ui_resource_created_++;
UIResourceId nid = next_id_++;
ui_resource_bitmap_map_.insert(
std::make_pair(nid, content->GetBitmap(nid, false)));
return nid;
}
// Deletes a UI resource. May safely be called more than once.
void DeleteUIResource(UIResourceId id) override {
auto iter = ui_resource_bitmap_map_.find(id);
if (iter != ui_resource_bitmap_map_.end()) {
ui_resource_bitmap_map_.erase(iter);
total_ui_resource_deleted_++;
}
}
size_t UIResourceCount() { return ui_resource_bitmap_map_.size(); }
int TotalUIResourceDeleted() { return total_ui_resource_deleted_; }
int TotalUIResourceCreated() { return total_ui_resource_created_; }
gfx::Size ui_resource_size(UIResourceId id) {
auto iter = ui_resource_bitmap_map_.find(id);
if (iter != ui_resource_bitmap_map_.end())
return iter->second.GetSize();
return gfx::Size();
}
UIResourceBitmap* ui_resource_bitmap(UIResourceId id) {
auto iter = ui_resource_bitmap_map_.find(id);
if (iter != ui_resource_bitmap_map_.end())
return &iter->second;
return nullptr;
}
private:
using UIResourceBitmapMap =
std::unordered_map<UIResourceId, UIResourceBitmap>;
UIResourceBitmapMap ui_resource_bitmap_map_;
StubLayerTreeHostSingleThreadClient single_thread_client_;
int next_id_;
int total_ui_resource_created_;
int total_ui_resource_deleted_;
};
class BaseScrollbarLayerTest : public testing::Test {
public:
explicit BaseScrollbarLayerTest(
LayerTreeSettings::ScrollbarAnimator animator) {
layer_tree_settings_.single_thread_proxy_scheduler = false;
layer_tree_settings_.use_zero_copy = true;
layer_tree_settings_.scrollbar_animator = animator;
layer_tree_settings_.scrollbar_fade_delay = base::Milliseconds(20);
layer_tree_settings_.scrollbar_fade_duration = base::Milliseconds(20);
animation_host_ = AnimationHost::CreateForTesting(ThreadInstance::MAIN);
LayerTreeHost::InitParams params;
params.client = &fake_client_;
params.settings = &layer_tree_settings_;
params.task_graph_runner = &task_graph_runner_;
params.mutator_host = animation_host_.get();
std::unique_ptr<FakeResourceTrackingUIResourceManager>
fake_ui_resource_manager =
std::make_unique<FakeResourceTrackingUIResourceManager>();
fake_ui_resource_manager_ = fake_ui_resource_manager.get();
layer_tree_host_ = std::make_unique<FakeLayerTreeHost>(
&fake_client_, std::move(params), CompositorMode::SINGLE_THREADED);
layer_tree_host_->SetUIResourceManagerForTesting(
std::move(fake_ui_resource_manager));
layer_tree_host_->InitializeSingleThreaded(
&single_thread_client_,
base::SingleThreadTaskRunner::GetCurrentDefault());
layer_tree_host_->SetVisible(true);
fake_client_.SetLayerTreeHost(layer_tree_host_.get());
}
protected:
raw_ptr<FakeResourceTrackingUIResourceManager> fake_ui_resource_manager_;
FakeLayerTreeHostClient fake_client_;
StubLayerTreeHostSingleThreadClient single_thread_client_;
TestTaskGraphRunner task_graph_runner_;
LayerTreeSettings layer_tree_settings_;
std::unique_ptr<AnimationHost> animation_host_;
std::unique_ptr<FakeLayerTreeHost> layer_tree_host_;
};
class ScrollbarLayerTest : public BaseScrollbarLayerTest {
public:
ScrollbarLayerTest()
: BaseScrollbarLayerTest(LayerTreeSettings::ANDROID_OVERLAY) {}
};
class AuraScrollbarLayerTest : public BaseScrollbarLayerTest {
public:
AuraScrollbarLayerTest()
: BaseScrollbarLayerTest(LayerTreeSettings::AURA_OVERLAY) {}
};
class FakePaintedOverlayScrollbar : public FakeScrollbar {
public:
FakePaintedOverlayScrollbar() {
set_should_paint(true);
set_has_thumb(true);
set_is_overlay(true);
}
bool UsesNinePatchThumbResource() const override { return true; }
gfx::Size NinePatchThumbCanvasSize() const override {
return gfx::Size(3, 3);
}
gfx::Rect NinePatchThumbAperture() const override {
return gfx::Rect(1, 1, 1, 1);
}
private:
~FakePaintedOverlayScrollbar() override = default;
};
// Test that a painted overlay scrollbar will repaint and recrate its resource
// after its been disposed, even if Blink doesn't think it requires a repaint.
// crbug.com/704656.
TEST_F(ScrollbarLayerTest, RepaintOverlayWhenResourceDisposed) {
scoped_refptr<Layer> layer_tree_root = Layer::Create();
scoped_refptr<Layer> content_layer = Layer::Create();
auto fake_scrollbar = base::MakeRefCounted<FakePaintedOverlayScrollbar>();
scoped_refptr<PaintedOverlayScrollbarLayer> scrollbar_layer =
PaintedOverlayScrollbarLayer::Create(fake_scrollbar);
scrollbar_layer->SetScrollElementId(layer_tree_root->element_id());
// Setup.
{
layer_tree_root->AddChild(content_layer);
layer_tree_root->AddChild(scrollbar_layer);
layer_tree_host_->SetRootLayer(layer_tree_root);
scrollbar_layer->SetIsDrawable(true);
scrollbar_layer->SetBounds(gfx::Size(100, 100));
layer_tree_root->SetBounds(gfx::Size(100, 200));
content_layer->SetBounds(gfx::Size(100, 200));
}
// First call to update should create a resource. The scrollbar itself thinks
// it needs a repaint.
{
fake_scrollbar->set_needs_repaint_thumb(true);
EXPECT_EQ(0u, fake_ui_resource_manager_->UIResourceCount());
EXPECT_TRUE(scrollbar_layer->Update());
EXPECT_EQ(1u, fake_ui_resource_manager_->UIResourceCount());
}
// Now the scrollbar has been painted and nothing else has changed, calling
// Update() shouldn't have an effect.
{
fake_scrollbar->set_needs_repaint_thumb(false);
EXPECT_FALSE(scrollbar_layer->Update());
EXPECT_EQ(1u, fake_ui_resource_manager_->UIResourceCount());
}
// Detach and reattach the LayerTreeHost (this can happen during tree
// reconstruction). This should cause the UIResource for the scrollbar to be
// disposed but the scrollbar itself hasn't changed so it reports that no
// repaint is needed. An Update should cause us to recreate the resource
// though.
{
scrollbar_layer->SetLayerTreeHost(nullptr);
scrollbar_layer->SetLayerTreeHost(layer_tree_host_.get());
EXPECT_EQ(0u, fake_ui_resource_manager_->UIResourceCount());
EXPECT_TRUE(scrollbar_layer->Update());
EXPECT_EQ(1u, fake_ui_resource_manager_->UIResourceCount());
}
}
TEST_F(ScrollbarLayerTest, SetNeedsDisplayDoesNotRequireUpdate) {
scoped_refptr<Layer> layer_tree_root = Layer::Create();
scoped_refptr<Layer> content_layer = Layer::Create();
scoped_refptr<FakePaintedScrollbarLayer> scrollbar_layer =
FakePaintedScrollbarLayer::Create(true, true,
layer_tree_root->element_id());
// Setup.
{
layer_tree_root->AddChild(content_layer);
layer_tree_root->AddChild(scrollbar_layer);
layer_tree_host_->SetRootLayer(layer_tree_root);
scrollbar_layer->SetIsDrawable(true);
scrollbar_layer->SetBounds(gfx::Size(100, 100));
layer_tree_root->SetBounds(gfx::Size(100, 200));
content_layer->SetBounds(gfx::Size(100, 200));
}
layer_tree_host_->UpdateLayers();
// Simulate commit to compositor thread.
scrollbar_layer->PushPropertiesTo(
scrollbar_layer->CreateLayerImpl(layer_tree_host_->active_tree()).get(),
*layer_tree_host_->GetPendingCommitState(),
layer_tree_host_->GetThreadUnsafeCommitState());
scrollbar_layer->fake_scrollbar()->set_needs_repaint_thumb(false);
scrollbar_layer->fake_scrollbar()->set_needs_repaint_track(false);
EXPECT_FALSE(scrollbar_layer->Update());
// Opacity changes should cause an update.
{
scrollbar_layer->fake_scrollbar()->set_thumb_opacity(0.3f);
EXPECT_TRUE(scrollbar_layer->Update());
}
// Needing a thumb repaint should cause an update.
{
scrollbar_layer->fake_scrollbar()->set_needs_repaint_thumb(true);
EXPECT_TRUE(scrollbar_layer->Update());
scrollbar_layer->fake_scrollbar()->set_needs_repaint_thumb(false);
EXPECT_FALSE(scrollbar_layer->Update());
}
// Needing a track repaint should cause an update.
{
scrollbar_layer->fake_scrollbar()->set_needs_repaint_track(true);
EXPECT_TRUE(scrollbar_layer->Update());
scrollbar_layer->fake_scrollbar()->set_needs_repaint_track(false);
EXPECT_FALSE(scrollbar_layer->Update());
}
// A scroll will cause |SetNeedsDisplay| to be called, but the scrollbar parts
// are used for invalidation, rather than the scrollbar layer itself. This
// should not cause an update. This is important for performance as an update
// will cause a commit on every scroll offset change.
{
scrollbar_layer->SetNeedsDisplay();
EXPECT_FALSE(scrollbar_layer->Update());
}
}
class FakeNinePatchScrollbar : public FakeScrollbar {
public:
FakeNinePatchScrollbar() {
set_should_paint(true);
set_has_thumb(true);
set_is_overlay(true);
}
bool UsesNinePatchThumbResource() const override { return true; }
private:
~FakeNinePatchScrollbar() override = default;
};
TEST_F(ScrollbarLayerTest, ScrollElementIdPushedAcrossCommit) {
scoped_refptr<Layer> layer_tree_root = Layer::Create();
scoped_refptr<Layer> layer_a = Layer::Create();
scoped_refptr<Layer> layer_b = Layer::Create();
layer_a->SetElementId(LayerIdToElementIdForTesting(layer_a->id()));
layer_b->SetElementId(LayerIdToElementIdForTesting(layer_b->id()));
scoped_refptr<PaintedScrollbarLayer> painted_scrollbar_layer =
PaintedScrollbarLayer::Create(base::MakeRefCounted<FakeScrollbar>());
painted_scrollbar_layer->SetScrollElementId(layer_a->element_id());
scoped_refptr<PaintedOverlayScrollbarLayer> painted_overlay_scrollbar_layer =
PaintedOverlayScrollbarLayer::Create(
base::MakeRefCounted<FakeNinePatchScrollbar>());
painted_overlay_scrollbar_layer->SetScrollElementId(layer_a->element_id());
scoped_refptr<SolidColorScrollbarLayer> solid_color_scrollbar_layer =
SolidColorScrollbarLayer::Create(ScrollbarOrientation::VERTICAL, 1, 1,
false);
solid_color_scrollbar_layer->SetScrollElementId(layer_a->element_id());
layer_tree_host_->SetRootLayer(layer_tree_root);
layer_tree_root->AddChild(layer_a);
layer_tree_root->AddChild(layer_b);
layer_tree_root->AddChild(painted_scrollbar_layer);
layer_tree_root->AddChild(painted_overlay_scrollbar_layer);
layer_tree_root->AddChild(solid_color_scrollbar_layer);
layer_tree_host_->UpdateLayers();
LayerImpl* layer_impl_tree_root =
layer_tree_host_->CommitAndCreateLayerImplTree();
ScrollbarLayerImplBase* painted_scrollbar_layer_impl =
static_cast<ScrollbarLayerImplBase*>(
layer_impl_tree_root->layer_tree_impl()->LayerById(
painted_scrollbar_layer->id()));
ScrollbarLayerImplBase* painted_overlay_scrollbar_layer_impl =
static_cast<ScrollbarLayerImplBase*>(
layer_impl_tree_root->layer_tree_impl()->LayerById(
painted_overlay_scrollbar_layer->id()));
ScrollbarLayerImplBase* solid_color_scrollbar_layer_impl =
static_cast<ScrollbarLayerImplBase*>(
layer_impl_tree_root->layer_tree_impl()->LayerById(
solid_color_scrollbar_layer->id()));
ASSERT_EQ(painted_scrollbar_layer_impl->scroll_element_id_,
layer_a->element_id());
ASSERT_EQ(painted_overlay_scrollbar_layer_impl->scroll_element_id_,
layer_a->element_id());
ASSERT_EQ(solid_color_scrollbar_layer_impl->scroll_element_id_,
layer_a->element_id());
painted_scrollbar_layer->SetScrollElementId(layer_b->element_id());
painted_overlay_scrollbar_layer->SetScrollElementId(layer_b->element_id());
solid_color_scrollbar_layer->SetScrollElementId(layer_b->element_id());
ASSERT_TRUE(layer_tree_host_->needs_commit());
// WillCommit(_, true) here will ensure that
// layer_tree_host_->active_commit_state() is populated, which is required
// during FinishCommitOnImplThread().
auto& unsafe_state = layer_tree_host_->GetThreadUnsafeCommitState();
auto completion_event_ptr = std::make_unique<CompletionEvent>(
base::WaitableEvent::ResetPolicy::MANUAL);
auto* completion_event = completion_event_ptr.get();
std::unique_ptr<CommitState> commit_state =
layer_tree_host_->WillCommit(std::move(completion_event_ptr),
/*has_updates=*/true);
{
DebugScopedSetImplThread scoped_impl_thread(
layer_tree_host_->GetTaskRunnerProvider());
layer_tree_host_->host_impl()->FinishCommit(*commit_state, unsafe_state);
completion_event->Signal();
}
layer_tree_host_->CommitComplete({base::TimeTicks(), base::TimeTicks::Now()});
EXPECT_EQ(painted_scrollbar_layer_impl->scroll_element_id_,
layer_b->element_id());
EXPECT_EQ(painted_overlay_scrollbar_layer_impl->scroll_element_id_,
layer_b->element_id());
EXPECT_EQ(solid_color_scrollbar_layer_impl->scroll_element_id_,
layer_b->element_id());
}
TEST_F(ScrollbarLayerTest, ScrollOffsetSynchronization) {
scoped_refptr<Layer> layer_tree_root = Layer::Create();
scoped_refptr<Layer> scroll_layer = Layer::Create();
scroll_layer->SetElementId(LayerIdToElementIdForTesting(scroll_layer->id()));
scoped_refptr<Layer> content_layer = Layer::Create();
scoped_refptr<PaintedScrollbarLayer> scrollbar_layer =
PaintedScrollbarLayer::Create(base::MakeRefCounted<FakeScrollbar>());
scrollbar_layer->SetScrollElementId(scroll_layer->element_id());
// Choose bounds to give max_scroll_offset = (30, 50).
layer_tree_root->SetBounds(gfx::Size(70, 150));
scroll_layer->SetScrollOffset(gfx::PointF(10, 20));
scroll_layer->SetBounds(gfx::Size(100, 200));
scroll_layer->SetScrollable(gfx::Size(70, 150));
content_layer->SetBounds(gfx::Size(100, 200));
layer_tree_host_->SetRootLayer(layer_tree_root);
layer_tree_root->AddChild(scroll_layer);
scroll_layer->AddChild(content_layer);
layer_tree_root->AddChild(scrollbar_layer);
layer_tree_host_->UpdateLayers();
LayerImpl* layer_impl_tree_root =
layer_tree_host_->CommitAndCreateLayerImplTree();
ScrollbarLayerImplBase* cc_scrollbar_layer =
static_cast<PaintedScrollbarLayerImpl*>(
layer_impl_tree_root->layer_tree_impl()->LayerById(
scrollbar_layer->id()));
layer_impl_tree_root->layer_tree_impl()->UpdateScrollbarGeometries();
EXPECT_EQ(10.f, cc_scrollbar_layer->current_pos());
EXPECT_EQ(30, cc_scrollbar_layer->scroll_layer_length() -
cc_scrollbar_layer->clip_layer_length());
layer_tree_root->SetBounds(gfx::Size(700, 1500));
scroll_layer->SetScrollable(gfx::Size(700, 1500));
scroll_layer->SetBounds(gfx::Size(1000, 2000));
scroll_layer->SetScrollOffset(gfx::PointF(100, 200));
content_layer->SetBounds(gfx::Size(1000, 2000));
layer_tree_host_->UpdateLayers();
layer_impl_tree_root = layer_tree_host_->CommitAndCreateLayerImplTree();
layer_impl_tree_root->layer_tree_impl()->UpdateScrollbarGeometries();
EXPECT_EQ(100.f, cc_scrollbar_layer->current_pos());
EXPECT_EQ(300, cc_scrollbar_layer->scroll_layer_length() -
cc_scrollbar_layer->clip_layer_length());
LayerImpl* scroll_layer_impl =
layer_impl_tree_root->layer_tree_impl()->LayerById(scroll_layer->id());
scroll_layer_impl->ScrollBy(gfx::Vector2d(12, 34));
layer_impl_tree_root->layer_tree_impl()->UpdateScrollbarGeometries();
EXPECT_EQ(112.f, cc_scrollbar_layer->current_pos());
EXPECT_EQ(300, cc_scrollbar_layer->scroll_layer_length() -
cc_scrollbar_layer->clip_layer_length());
}
#define UPDATE_AND_EXTRACT_LAYER_POINTERS() \
do { \
scrollbar_layer->UpdateInternalContentScale(); \
scrollbar_layer->UpdateThumbAndTrackGeometry(); \
root_layer_impl = layer_tree_host_->CommitAndCreateLayerImplTree(); \
root_layer_impl->layer_tree_impl()->UpdateScrollbarGeometries(); \
scrollbar_layer_impl = static_cast<PaintedScrollbarLayerImpl*>( \
root_layer_impl->layer_tree_impl()->LayerById(scrollbar_layer->id())); \
} while (false)
TEST_F(ScrollbarLayerTest, UpdatePropertiesOfScrollBarWhenThumbRemoved) {
scoped_refptr<Layer> root_layer = Layer::Create();
scoped_refptr<Layer> content_layer = Layer::Create();
scoped_refptr<FakePaintedScrollbarLayer> scrollbar_layer =
FakePaintedScrollbarLayer::Create(false, true, root_layer->element_id());
// Give the root layer a size that will result in MaxScrollOffset = (80, 0).
root_layer->SetScrollable(gfx::Size(20, 50));
root_layer->SetBounds(gfx::Size(100, 50));
content_layer->SetBounds(gfx::Size(100, 50));
layer_tree_host_->SetRootLayer(root_layer);
root_layer->AddChild(content_layer);
root_layer->AddChild(scrollbar_layer);
root_layer->SetScrollOffset(gfx::PointF(0, 0));
scrollbar_layer->SetBounds(gfx::Size(70, 10));
// The track_rect should be relative to the scrollbar's origin.
scrollbar_layer->fake_scrollbar()->set_track_rect(gfx::Rect(10, 10, 50, 10));
scrollbar_layer->fake_scrollbar()->set_thumb_size(gfx::Size(4, 10));
LayerImpl* root_layer_impl = nullptr;
PaintedScrollbarLayerImpl* scrollbar_layer_impl = nullptr;
layer_tree_host_->BuildPropertyTreesForTesting();
UPDATE_AND_EXTRACT_LAYER_POINTERS();
EXPECT_EQ(gfx::Rect(10, 0, 4, 10).ToString(),
scrollbar_layer_impl->ComputeThumbQuadRect().ToString());
scrollbar_layer->fake_scrollbar()->set_has_thumb(false);
UPDATE_AND_EXTRACT_LAYER_POINTERS();
EXPECT_EQ(gfx::Rect(10, 0, 0, 0).ToString(),
scrollbar_layer_impl->ComputeThumbQuadRect().ToString());
}
TEST_F(ScrollbarLayerTest, ThumbRect) {
scoped_refptr<Layer> root_layer = Layer::Create();
root_layer->SetElementId(LayerIdToElementIdForTesting(root_layer->id()));
scoped_refptr<Layer> content_layer = Layer::Create();
scoped_refptr<FakePaintedScrollbarLayer> scrollbar_layer =
FakePaintedScrollbarLayer::Create(false, true, root_layer->element_id());
// Give the root layer a size that will result in MaxScrollOffset = (80, 0).
root_layer->SetScrollable(gfx::Size(20, 50));
root_layer->SetBounds(gfx::Size(100, 50));
content_layer->SetBounds(gfx::Size(100, 50));
layer_tree_host_->SetRootLayer(root_layer);
root_layer->AddChild(content_layer);
root_layer->AddChild(scrollbar_layer);
root_layer->SetScrollOffset(gfx::PointF(0, 0));
scrollbar_layer->SetBounds(gfx::Size(70, 10));
// The track_rect should be relative to the scrollbar's origin.
scrollbar_layer->fake_scrollbar()->set_track_rect(gfx::Rect(10, 10, 50, 10));
scrollbar_layer->fake_scrollbar()->set_thumb_size(gfx::Size(4, 10));
layer_tree_host_->UpdateLayers();
LayerImpl* root_layer_impl = nullptr;
PaintedScrollbarLayerImpl* scrollbar_layer_impl = nullptr;
// Thumb is at the edge of the scrollbar (should be inset to
// the start of the track within the scrollbar layer's
// position).
UPDATE_AND_EXTRACT_LAYER_POINTERS();
EXPECT_EQ(gfx::Rect(10, 0, 4, 10).ToString(),
scrollbar_layer_impl->ComputeThumbQuadRect().ToString());
// Under-scroll (thumb position should clamp and be unchanged).
root_layer->SetScrollOffset(gfx::PointF(-5, 0));
UPDATE_AND_EXTRACT_LAYER_POINTERS();
EXPECT_EQ(gfx::Rect(10, 0, 4, 10).ToString(),
scrollbar_layer_impl->ComputeThumbQuadRect().ToString());
// Over-scroll (thumb position should clamp on the far side).
root_layer->SetScrollOffset(gfx::PointF(85, 0));
layer_tree_host_->UpdateLayers();
UPDATE_AND_EXTRACT_LAYER_POINTERS();
EXPECT_EQ(gfx::Rect(56, 0, 4, 10).ToString(),
scrollbar_layer_impl->ComputeThumbQuadRect().ToString());
// Change thumb thickness and length.
scrollbar_layer->fake_scrollbar()->set_thumb_size(gfx::Size(6, 4));
UPDATE_AND_EXTRACT_LAYER_POINTERS();
EXPECT_EQ(gfx::Rect(54, 0, 6, 4).ToString(),
scrollbar_layer_impl->ComputeThumbQuadRect().ToString());
// Shrink the scrollbar layer to cover only the track.
scrollbar_layer->SetBounds(gfx::Size(50, 10));
scrollbar_layer->fake_scrollbar()->set_track_rect(gfx::Rect(0, 10, 50, 10));
UPDATE_AND_EXTRACT_LAYER_POINTERS();
EXPECT_EQ(gfx::Rect(44, 0, 6, 4).ToString(),
scrollbar_layer_impl->ComputeThumbQuadRect().ToString());
// Shrink the track in the non-scrolling dimension so that it only covers the
// middle third of the scrollbar layer (this does not affect the thumb
// position).
scrollbar_layer->fake_scrollbar()->set_track_rect(gfx::Rect(0, 12, 50, 6));
UPDATE_AND_EXTRACT_LAYER_POINTERS();
EXPECT_EQ(gfx::Rect(44, 0, 6, 4).ToString(),
scrollbar_layer_impl->ComputeThumbQuadRect().ToString());
}
TEST_F(ScrollbarLayerTest, ThumbRectForOverlayLeftSideVerticalScrollbar) {
scoped_refptr<Layer> root_layer = Layer::Create();
// Create an overlay left side vertical scrollbar.
scoped_refptr<FakePaintedScrollbarLayer> scrollbar_layer =
FakePaintedScrollbarLayer::Create(false, true,
ScrollbarOrientation::VERTICAL, true,
true, root_layer->element_id());
root_layer->SetScrollable(gfx::Size(20, 50));
root_layer->SetBounds(gfx::Size(50, 100));
layer_tree_host_->SetRootLayer(root_layer);
root_layer->AddChild(scrollbar_layer);
root_layer->SetScrollOffset(gfx::PointF(0, 0));
scrollbar_layer->SetBounds(gfx::Size(10, 20));
scrollbar_layer->fake_scrollbar()->set_track_rect(gfx::Rect(0, 0, 10, 20));
scrollbar_layer->fake_scrollbar()->set_thumb_size(gfx::Size(10, 4));
layer_tree_host_->UpdateLayers();
LayerImpl* root_layer_impl = nullptr;
PaintedScrollbarLayerImpl* scrollbar_layer_impl = nullptr;
// Thumb is at the edge of the scrollbar (should be inset to
// the start of the track within the scrollbar layer's
// position).
UPDATE_AND_EXTRACT_LAYER_POINTERS();
EXPECT_EQ(gfx::Rect(0, 0, 10, 4).ToString(),
scrollbar_layer_impl->ComputeThumbQuadRect().ToString());
// Change thumb thickness scale factor.
scrollbar_layer_impl->SetThumbThicknessScaleFactor(0.5);
UPDATE_AND_EXTRACT_LAYER_POINTERS();
// For overlay scrollbars thumb_rect.width = thumb_thickness *
// thumb_thickness_scale_factor.
EXPECT_EQ(gfx::Rect(0, 0, 5, 4).ToString(),
scrollbar_layer_impl->ComputeThumbQuadRect().ToString());
// Change thumb thickness and length.
scrollbar_layer->fake_scrollbar()->set_thumb_size(gfx::Size(4, 6));
UPDATE_AND_EXTRACT_LAYER_POINTERS();
// For left side vertical scrollbars thumb_rect.x = bounds.width() -
// thumb_thickness.
EXPECT_EQ(gfx::Rect(6, 0, 2, 6).ToString(),
scrollbar_layer_impl->ComputeThumbQuadRect().ToString());
}
TEST_F(ScrollbarLayerTest, SolidColorDrawQuads) {
const int kThumbThickness = 3;
const int kTrackStart = 1;
const int kTrackLength = 100;
ScrollbarLayerImplBase* scrollbar_layer_impl = nullptr;
{
scoped_refptr<Layer> root = Layer::Create();
scoped_refptr<Layer> child = Layer::Create();
scoped_refptr<ScrollbarLayerBase> scrollbar_layer =
SolidColorScrollbarLayer::Create(ScrollbarOrientation::HORIZONTAL,
kThumbThickness, kTrackStart, false);
root->AddChild(child);
root->AddChild(scrollbar_layer);
layer_tree_host_->SetRootLayer(root);
layer_tree_host_->BuildPropertyTreesForTesting();
auto* root_impl = layer_tree_host_->CommitAndCreateLayerImplTree();
scrollbar_layer_impl = static_cast<SolidColorScrollbarLayerImpl*>(
root_impl->layer_tree_impl()->LayerById(scrollbar_layer->id()));
}
scrollbar_layer_impl->SetBounds(gfx::Size(kTrackLength, kThumbThickness));
scrollbar_layer_impl->SetCurrentPos(10.f);
scrollbar_layer_impl->SetClipLayerLength(200 / 3.f);
scrollbar_layer_impl->SetScrollLayerLength(100 + 200 / 3.f);
// Thickness should be overridden to 3.
{
auto render_pass = viz::CompositorRenderPass::Create();
AppendQuadsData data;
scrollbar_layer_impl->AppendQuads(render_pass.get(), &data);
const auto& quads = render_pass->quad_list;
ASSERT_EQ(1u, quads.size());
EXPECT_EQ(viz::DrawQuad::Material::kSolidColor, quads.front()->material);
EXPECT_EQ(gfx::Rect(6, 0, 39, 3), quads.front()->rect);
}
// For solid color scrollbars, position and size should reflect the
// current viewport state.
scrollbar_layer_impl->SetClipLayerLength(25.f);
scrollbar_layer_impl->SetScrollLayerLength(125.f);
{
auto render_pass = viz::CompositorRenderPass::Create();
AppendQuadsData data;
scrollbar_layer_impl->AppendQuads(render_pass.get(), &data);
const auto& quads = render_pass->quad_list;
ASSERT_EQ(1u, quads.size());
EXPECT_EQ(viz::DrawQuad::Material::kSolidColor, quads.front()->material);
EXPECT_EQ(gfx::Rect(8, 0, 19, 3), quads.front()->rect);
}
// We shouldn't attempt div-by-zero when the maximum is zero.
scrollbar_layer_impl->SetCurrentPos(0.f);
scrollbar_layer_impl->SetClipLayerLength(125.f);
scrollbar_layer_impl->SetScrollLayerLength(125.f);
{
auto render_pass = viz::CompositorRenderPass::Create();
AppendQuadsData data;
scrollbar_layer_impl->AppendQuads(render_pass.get(), &data);
const auto& quads = render_pass->quad_list;
ASSERT_EQ(1u, quads.size());
EXPECT_EQ(viz::DrawQuad::Material::kSolidColor, quads.front()->material);
EXPECT_EQ(gfx::Rect(1, 0, 98, 3), quads.front()->rect);
}
}
TEST_F(ScrollbarLayerTest, LayerDrivenSolidColorDrawQuads) {
const int kThumbThickness = 3;
const int kTrackStart = 0;
const int kTrackLength = 10;
scoped_refptr<Layer> layer_tree_root = Layer::Create();
scoped_refptr<Layer> scroll_layer = Layer::Create();
scroll_layer->SetElementId(LayerIdToElementIdForTesting(scroll_layer->id()));
scoped_refptr<Layer> child1 = Layer::Create();
const bool kIsLeftSideVerticalScrollbar = false;
scoped_refptr<SolidColorScrollbarLayer> child2 =
SolidColorScrollbarLayer::Create(ScrollbarOrientation::HORIZONTAL,
kThumbThickness, kTrackStart,
kIsLeftSideVerticalScrollbar);
child2->SetScrollElementId(scroll_layer->element_id());
scroll_layer->AddChild(child1);
scroll_layer->InsertChild(child2, 1);
layer_tree_root->AddChild(scroll_layer);
layer_tree_host_->SetRootLayer(layer_tree_root);
// Choose layer bounds to give max_scroll_offset = (8, 8).
layer_tree_root->SetBounds(gfx::Size(2, 2));
scroll_layer->SetScrollable(gfx::Size(2, 2));
scroll_layer->SetBounds(gfx::Size(10, 10));
layer_tree_host_->UpdateLayers();
LayerImpl* layer_impl_tree_root =
layer_tree_host_->CommitAndCreateLayerImplTree();
LayerImpl* scroll_layer_impl =
layer_impl_tree_root->layer_tree_impl()->LayerById(scroll_layer->id());
auto* scrollbar_layer_impl = static_cast<ScrollbarLayerImplBase*>(
scroll_layer_impl->layer_tree_impl()->LayerById(child2->id()));
scroll_layer_impl->ScrollBy(gfx::Vector2dF(4.f, 0.f));
scrollbar_layer_impl->SetBounds(gfx::Size(kTrackLength, kThumbThickness));
scrollbar_layer_impl->SetCurrentPos(4.f);
DCHECK(layer_tree_host_->active_tree()->ScrollbarGeometriesNeedUpdate());
layer_tree_host_->active_tree()->UpdateScrollbarGeometries();
{
auto render_pass = viz::CompositorRenderPass::Create();
AppendQuadsData data;
scrollbar_layer_impl->AppendQuads(render_pass.get(), &data);
const auto& quads = render_pass->quad_list;
ASSERT_EQ(1u, quads.size());
EXPECT_EQ(viz::DrawQuad::Material::kSolidColor, quads.front()->material);
EXPECT_EQ(gfx::Rect(3, 0, 3, 3), quads.front()->rect);
}
}
TEST_F(ScrollbarLayerTest, ScrollbarLayerOpacity) {
const int kThumbThickness = 3;
const int kTrackStart = 0;
scoped_refptr<Layer> layer_tree_root = Layer::Create();
scoped_refptr<Layer> scroll_layer = Layer::Create();
scroll_layer->SetElementId(ElementId(200));
scoped_refptr<Layer> child1 = Layer::Create();
scoped_refptr<SolidColorScrollbarLayer> scrollbar_layer;
const bool kIsLeftSideVerticalScrollbar = false;
scrollbar_layer = SolidColorScrollbarLayer::Create(
ScrollbarOrientation::HORIZONTAL, kThumbThickness, kTrackStart,
kIsLeftSideVerticalScrollbar);
scrollbar_layer->SetScrollElementId(scroll_layer->element_id());
scrollbar_layer->SetElementId(ElementId(300));
scroll_layer->AddChild(child1);
scroll_layer->InsertChild(scrollbar_layer, 1);
layer_tree_root->AddChild(scroll_layer);
layer_tree_host_->SetRootLayer(layer_tree_root);
// Choose layer bounds to give max_scroll_offset = (8, 8).
layer_tree_root->SetBounds(gfx::Size(2, 2));
scroll_layer->SetBounds(gfx::Size(10, 10));
// Building property trees twice shouldn't change the size of
// PropertyTrees::always_use_active_tree_opacity_effect_ids.
layer_tree_host_->BuildPropertyTreesForTesting();
layer_tree_host_->property_trees()->set_needs_rebuild(true);
layer_tree_host_->BuildPropertyTreesForTesting();
// A solid color scrollbar layer's opacity is initialized to 0 on main thread
layer_tree_host_->UpdateLayers();
const EffectNode* node =
layer_tree_host_->property_trees()->effect_tree().Node(
scrollbar_layer->effect_tree_index());
EXPECT_EQ(node->opacity, 0.f);
// This tests that the initial opacity(0) of the scrollbar gets pushed onto
// the pending tree and then onto the active tree.
LayerTreeHostImpl* host_impl = layer_tree_host_->host_impl();
host_impl->CreatePendingTree();
LayerImpl* layer_impl_tree_root =
layer_tree_host_->CommitAndCreatePendingTree();
LayerTreeImpl* layer_tree_impl = layer_impl_tree_root->layer_tree_impl();
EXPECT_TRUE(layer_tree_impl->IsPendingTree());
node = layer_tree_impl->property_trees()->effect_tree().Node(
scrollbar_layer->effect_tree_index());
EXPECT_EQ(node->opacity, 0.f);
host_impl->ActivateSyncTree();
layer_tree_impl = host_impl->active_tree();
node = layer_tree_impl->property_trees()->effect_tree().Node(
scrollbar_layer->effect_tree_index());
EXPECT_EQ(node->opacity, 0.f);
// This tests that activation does not change the opacity of scrollbar layer.
ScrollbarLayerImplBase* scrollbar_layer_impl =
static_cast<ScrollbarLayerImplBase*>(
layer_tree_impl->LayerById(scrollbar_layer->id()));
scrollbar_layer_impl->SetOverlayScrollbarLayerOpacityAnimated(0.25f);
host_impl->CreatePendingTree();
layer_impl_tree_root = layer_tree_host_->CommitAndCreatePendingTree();
layer_tree_impl = layer_impl_tree_root->layer_tree_impl();
EXPECT_TRUE(layer_tree_impl->IsPendingTree());
node = layer_tree_impl->property_trees()->effect_tree().Node(
scrollbar_layer->effect_tree_index());
EXPECT_EQ(node->opacity, 0.f);
host_impl->ActivateSyncTree();
layer_tree_impl = host_impl->active_tree();
node = layer_tree_impl->property_trees()->effect_tree().Node(
scrollbar_layer->effect_tree_index());
EXPECT_EQ(node->opacity, 0.25f);
}
TEST_F(AuraScrollbarLayerTest, ScrollbarLayerPushProperties) {
// Pushing changed bounds of scroll layer can lead to calling
// OnOpacityAnimated on scrollbar layer which means OnOpacityAnimated should
// be independent of scrollbar layer's properties as scrollbar layer can push
// its properties after scroll layer.
const int kThumbThickness = 3;
const int kTrackStart = 0;
scoped_refptr<Layer> layer_tree_root = Layer::Create();
scoped_refptr<Layer> scroll_layer = Layer::Create();
scroll_layer->SetElementId(LayerIdToElementIdForTesting(scroll_layer->id()));
scoped_refptr<Layer> child1 = Layer::Create();
const bool kIsLeftSideVerticalScrollbar = false;
scoped_refptr<SolidColorScrollbarLayer> scrollbar_layer =
SolidColorScrollbarLayer::Create(ScrollbarOrientation::HORIZONTAL,
kThumbThickness, kTrackStart,
kIsLeftSideVerticalScrollbar);
scrollbar_layer->SetScrollElementId(scroll_layer->element_id());
scroll_layer->AddChild(child1);
scroll_layer->InsertChild(scrollbar_layer, 1);
layer_tree_root->AddChild(scroll_layer);
layer_tree_host_->SetRootLayer(layer_tree_root);
layer_tree_root->SetBounds(gfx::Size(2, 2));
scroll_layer->SetBounds(gfx::Size(10, 10));
scroll_layer->SetScrollable(layer_tree_root->bounds());
layer_tree_host_->UpdateLayers();
LayerTreeHostImpl* host_impl = layer_tree_host_->host_impl();
host_impl->CreatePendingTree();
layer_tree_host_->CommitAndCreatePendingTree();
host_impl->ActivateSyncTree();
EXPECT_TRUE(host_impl->ScrollbarAnimationControllerForElementId(
scroll_layer->element_id()));
scroll_layer->SetBounds(gfx::Size(20, 20));
scroll_layer->SetForceRenderSurfaceForTesting(true);
layer_tree_host_->UpdateLayers();
host_impl->CreatePendingTree();
layer_tree_host_->CommitAndCreatePendingTree();
host_impl->ActivateSyncTree();
const EffectNode* node =
host_impl->active_tree()->property_trees()->effect_tree().Node(
scrollbar_layer->effect_tree_index());
EXPECT_EQ(node->opacity, 1.f);
}
TEST_F(ScrollbarLayerTest, SubPixelCanScrollOrientation) {
gfx::Size viewport_size(980, 980);
LayerTreeImplTestBase impl;
LayerImpl* scroll_layer = impl.AddLayer<LayerImpl>();
scroll_layer->SetElementId(LayerIdToElementIdForTesting(scroll_layer->id()));
const int kTrackStart = 0;
const int kThumbThickness = 10;
const bool kIsLeftSideVerticalScrollbar = false;
SolidColorScrollbarLayerImpl* scrollbar_layer =
impl.AddLayer<SolidColorScrollbarLayerImpl>(
ScrollbarOrientation::HORIZONTAL, kThumbThickness, kTrackStart,
kIsLeftSideVerticalScrollbar);
scrollbar_layer->SetScrollElementId(scroll_layer->element_id());
scroll_layer->SetBounds(gfx::Size(980, 980));
CopyProperties(impl.root_layer(), scroll_layer);
CreateTransformNode(scroll_layer);
CreateScrollNode(scroll_layer, gfx::Size(980, 980));
CopyProperties(scroll_layer, scrollbar_layer);
DCHECK(impl.host_impl()->active_tree()->ScrollbarGeometriesNeedUpdate());
impl.host_impl()->active_tree()->UpdateScrollbarGeometries();
impl.CalcDrawProps(viewport_size);
// Fake clip layer length to scrollbar to mock rounding error.
scrollbar_layer->SetClipLayerLength(979.999939f);
impl.CalcDrawProps(viewport_size);
EXPECT_FALSE(scrollbar_layer->CanScrollOrientation());
// Fake clip layer length to scrollable.
scrollbar_layer->SetClipLayerLength(979.0f);
impl.CalcDrawProps(viewport_size);
EXPECT_TRUE(scrollbar_layer->CanScrollOrientation());
}
TEST_F(ScrollbarLayerTest, LayerChangesAffectingScrollbarGeometries) {
LayerTreeImplTestBase impl;
SetupViewport(impl.root_layer(), gfx::Size(), gfx::Size(900, 900));
auto* scroll_layer = impl.OuterViewportScrollLayer();
EXPECT_FALSE(GetScrollNode(scroll_layer)->scrollable);
const int kTrackStart = 0;
const int kThumbThickness = 10;
const bool kIsLeftSideVerticalScrollbar = false;
SolidColorScrollbarLayerImpl* scrollbar_layer =
impl.AddLayer<SolidColorScrollbarLayerImpl>(
ScrollbarOrientation::HORIZONTAL, kThumbThickness, kTrackStart,
kIsLeftSideVerticalScrollbar);
scrollbar_layer->SetScrollElementId(scroll_layer->element_id());
EXPECT_TRUE(impl.host_impl()->active_tree()->ScrollbarGeometriesNeedUpdate());
impl.host_impl()->active_tree()->UpdateScrollbarGeometries();
GetScrollNode(scroll_layer)->container_bounds = gfx::Size(900, 900);
scroll_layer->SetBounds(gfx::Size(900, 900));
scroll_layer->UpdateScrollable();
EXPECT_FALSE(GetScrollNode(scroll_layer)->scrollable);
// If the scroll layer is not scrollable, the bounds and the container bounds
// do not affect scrollbar geometries.
EXPECT_FALSE(
impl.host_impl()->active_tree()->ScrollbarGeometriesNeedUpdate());
// Changing scrollable to true should require an update.
GetScrollNode(scroll_layer)->scrollable = true;
scroll_layer->UpdateScrollable();
EXPECT_TRUE(impl.host_impl()->active_tree()->ScrollbarGeometriesNeedUpdate());
impl.host_impl()->active_tree()->UpdateScrollbarGeometries();
scroll_layer->SetBounds(gfx::Size(980, 980));
// Changes to the bounds should also require an update.
EXPECT_TRUE(impl.host_impl()->active_tree()->ScrollbarGeometriesNeedUpdate());
impl.host_impl()->active_tree()->UpdateScrollbarGeometries();
// Changes to the container bounds should require an update.
GetScrollNode(scroll_layer)->container_bounds = gfx::Size(500, 500);
scroll_layer->UpdateScrollable();
EXPECT_TRUE(impl.host_impl()->active_tree()->ScrollbarGeometriesNeedUpdate());
impl.host_impl()->active_tree()->UpdateScrollbarGeometries();
// Not changing the current value should not require an update.
scroll_layer->SetBounds(gfx::Size(980, 980));
EXPECT_FALSE(
impl.host_impl()->active_tree()->ScrollbarGeometriesNeedUpdate());
scroll_layer->UpdateScrollable();
EXPECT_FALSE(
impl.host_impl()->active_tree()->ScrollbarGeometriesNeedUpdate());
// Changing scrollable to false should require an update.
GetScrollNode(scroll_layer)->scrollable = false;
scroll_layer->UpdateScrollable();
EXPECT_TRUE(impl.host_impl()->active_tree()->ScrollbarGeometriesNeedUpdate());
impl.host_impl()->active_tree()->UpdateScrollbarGeometries();
}
TEST_F(ScrollbarLayerTest, UpdateScrollbarGeometriesScrollNodeOnContainer) {
LayerTreeImplTestBase impl;
LayerImpl* scroll_layer = impl.AddLayer<LayerImpl>();
scroll_layer->SetElementId(LayerIdToElementIdForTesting(scroll_layer->id()));
scroll_layer->SetBounds(gfx::Size(100, 100));
CopyProperties(impl.root_layer(), scroll_layer);
CreateTransformNode(scroll_layer);
// In CompositeAfterPaint, the scroll node is associated with the scroll
// container layer. Its |container_bounds| is the same as the bounds of the
// layer, and its |bounds| is the bounds of the scrolling contents.
CreateScrollNode(scroll_layer, gfx::Size(100, 100)).bounds =
gfx::Size(1000, 1000);
EXPECT_TRUE(impl.host_impl()->active_tree()->ScrollbarGeometriesNeedUpdate());
impl.host_impl()->active_tree()->UpdateScrollbarGeometries();
GetScrollNode(scroll_layer)->bounds = gfx::Size(1000, 2000);
scroll_layer->UpdateScrollable();
EXPECT_TRUE(impl.host_impl()->active_tree()->ScrollbarGeometriesNeedUpdate());
impl.host_impl()->active_tree()->UpdateScrollbarGeometries();
scroll_layer->UpdateScrollable();
EXPECT_FALSE(
impl.host_impl()->active_tree()->ScrollbarGeometriesNeedUpdate());
impl.host_impl()->active_tree()->UpdateScrollbarGeometries();
}
TEST_F(AuraScrollbarLayerTest, ScrollbarLayerCreateAfterSetScrollable) {
// Scrollbar Layer can be created after SetScrollable is called and in a
// separate commit. Ensure we do not missing the DidRequestShowFromMainThread
// call.
const int kThumbThickness = 3;
const int kTrackStart = 0;
scoped_refptr<Layer> layer_tree_root = Layer::Create();
scoped_refptr<Layer> scroll_layer = Layer::Create();
scroll_layer->SetElementId(LayerIdToElementIdForTesting(scroll_layer->id()));
scoped_refptr<Layer> child1 = Layer::Create();
const bool kIsLeftSideVerticalScrollbar = false;
scroll_layer->AddChild(child1);
layer_tree_root->AddChild(scroll_layer);
layer_tree_host_->SetRootLayer(layer_tree_root);
layer_tree_root->SetBounds(gfx::Size(2, 2));
scroll_layer->SetBounds(gfx::Size(10, 10));
scroll_layer->SetScrollable(layer_tree_root->bounds());
layer_tree_host_->UpdateLayers();
LayerTreeHostImpl* host_impl = layer_tree_host_->host_impl();
host_impl->CreatePendingTree();
layer_tree_host_->CommitAndCreatePendingTree();
host_impl->ActivateSyncTree();
scoped_refptr<SolidColorScrollbarLayer> scrollbar_layer =
SolidColorScrollbarLayer::Create(ScrollbarOrientation::HORIZONTAL,
kThumbThickness, kTrackStart,
kIsLeftSideVerticalScrollbar);
scrollbar_layer->SetScrollElementId(scroll_layer->element_id());
scroll_layer->InsertChild(scrollbar_layer, 1);
layer_tree_host_->UpdateLayers();
host_impl->CreatePendingTree();
layer_tree_host_->CommitAndCreatePendingTree();
host_impl->ActivateSyncTree();
EXPECT_TRUE(host_impl->ScrollbarAnimationControllerForElementId(
scroll_layer->element_id()));
const EffectNode* node =
host_impl->active_tree()->property_trees()->effect_tree().Node(
scrollbar_layer->effect_tree_index());
EXPECT_EQ(node->opacity, 1.f);
}
class ScrollbarLayerSolidColorThumbTest : public testing::Test {
public:
ScrollbarLayerSolidColorThumbTest() {
LayerTreeSettings layer_tree_settings;
host_impl_ = std::make_unique<FakeLayerTreeHostImpl>(
layer_tree_settings, &task_runner_provider_, &task_graph_runner_);
const int kThumbThickness = 3;
const int kTrackStart = 0;
const bool kIsLeftSideVerticalScrollbar = false;
horizontal_scrollbar_layer_ = SolidColorScrollbarLayerImpl::Create(
host_impl_->active_tree(), 1, ScrollbarOrientation::HORIZONTAL,
kThumbThickness, kTrackStart, kIsLeftSideVerticalScrollbar);
vertical_scrollbar_layer_ = SolidColorScrollbarLayerImpl::Create(
host_impl_->active_tree(), 2, ScrollbarOrientation::VERTICAL,
kThumbThickness, kTrackStart, kIsLeftSideVerticalScrollbar);
}
protected:
FakeImplTaskRunnerProvider task_runner_provider_;
TestTaskGraphRunner task_graph_runner_;
std::unique_ptr<FakeLayerTreeHostImpl> host_impl_;
std::unique_ptr<SolidColorScrollbarLayerImpl> horizontal_scrollbar_layer_;
std::unique_ptr<SolidColorScrollbarLayerImpl> vertical_scrollbar_layer_;
};
TEST_F(ScrollbarLayerSolidColorThumbTest, SolidColorThumbLength) {
horizontal_scrollbar_layer_->SetCurrentPos(0);
// Simple case - one third of the scrollable area is visible, so the thumb
// should be one third as long as the track.
horizontal_scrollbar_layer_->SetClipLayerLength(5.f);
horizontal_scrollbar_layer_->SetScrollLayerLength(15.f);
horizontal_scrollbar_layer_->SetBounds(gfx::Size(100, 3));
EXPECT_EQ(33, horizontal_scrollbar_layer_->ComputeThumbQuadRect().width());
// The thumb's length should never be less than its thickness.
horizontal_scrollbar_layer_->SetClipLayerLength(0.01f);
horizontal_scrollbar_layer_->SetScrollLayerLength(15.f);
horizontal_scrollbar_layer_->SetBounds(gfx::Size(100, 3));
EXPECT_EQ(3, horizontal_scrollbar_layer_->ComputeThumbQuadRect().width());
}
TEST_F(ScrollbarLayerSolidColorThumbTest, SolidColorThumbPosition) {
horizontal_scrollbar_layer_->SetBounds(gfx::Size(100, 3));
horizontal_scrollbar_layer_->SetCurrentPos(0.f);
horizontal_scrollbar_layer_->SetClipLayerLength(12.f);
horizontal_scrollbar_layer_->SetScrollLayerLength(112.f);
EXPECT_EQ(0, horizontal_scrollbar_layer_->ComputeThumbQuadRect().x());
EXPECT_EQ(10, horizontal_scrollbar_layer_->ComputeThumbQuadRect().width());
horizontal_scrollbar_layer_->SetCurrentPos(100);
// The thumb is 10px long and the track is 100px, so the maximum thumb
// position is 90px.
EXPECT_EQ(90, horizontal_scrollbar_layer_->ComputeThumbQuadRect().x());
horizontal_scrollbar_layer_->SetCurrentPos(80);
// The scroll position is 80% of the maximum, so the thumb's position should
// be at 80% of its maximum or 72px.
EXPECT_EQ(72, horizontal_scrollbar_layer_->ComputeThumbQuadRect().x());
}
TEST_F(ScrollbarLayerSolidColorThumbTest, SolidColorThumbVerticalAdjust) {
SolidColorScrollbarLayerImpl* layers[2] =
{ horizontal_scrollbar_layer_.get(), vertical_scrollbar_layer_.get() };
for (size_t i = 0; i < 2; ++i) {
layers[i]->SetCurrentPos(25.f);
layers[i]->SetClipLayerLength(25.f);
layers[i]->SetScrollLayerLength(125.f);
}
layers[0]->SetBounds(gfx::Size(100, 3));
layers[1]->SetBounds(gfx::Size(3, 100));
EXPECT_EQ(gfx::Rect(20, 0, 20, 3),
horizontal_scrollbar_layer_->ComputeThumbQuadRect());
EXPECT_EQ(gfx::Rect(0, 20, 3, 20),
vertical_scrollbar_layer_->ComputeThumbQuadRect());
horizontal_scrollbar_layer_->SetVerticalAdjust(10.f);
vertical_scrollbar_layer_->SetVerticalAdjust(10.f);
// The vertical adjustment factor has two effects:
// 1.) Moves the horizontal scrollbar down
// 2.) Increases the vertical scrollbar's effective track length which both
// increases the thumb's length and its position within the track.
EXPECT_EQ(gfx::Rect(20.f, 10.f, 20.f, 3.f),
horizontal_scrollbar_layer_->ComputeThumbQuadRect());
EXPECT_EQ(gfx::Rect(0.f, 22, 3.f, 22.f),
vertical_scrollbar_layer_->ComputeThumbQuadRect());
}
class ScrollbarLayerTestResourceCreationAndRelease : public ScrollbarLayerTest {
public:
void TestResourceUpload(int num_updates,
size_t expected_resources,
int expected_created,
int expected_deleted,
bool use_solid_color_scrollbar) {
scoped_refptr<Layer> layer_tree_root = Layer::Create();
scoped_refptr<Layer> content_layer = Layer::Create();
scoped_refptr<ScrollbarLayerBase> scrollbar_layer;
if (use_solid_color_scrollbar) {
const int kThumbThickness = 3;
const int kTrackStart = 0;
const bool kIsLeftSideVerticalScrollbar = false;
scrollbar_layer = SolidColorScrollbarLayer::Create(
ScrollbarOrientation::HORIZONTAL, kThumbThickness, kTrackStart,
kIsLeftSideVerticalScrollbar);
} else {
auto scrollbar = base::MakeRefCounted<FakeScrollbar>();
scrollbar->set_has_thumb(true);
scrollbar_layer = PaintedScrollbarLayer::Create(std::move(scrollbar));
}
scrollbar_layer->SetScrollElementId(layer_tree_root->element_id());
layer_tree_root->AddChild(content_layer);
layer_tree_root->AddChild(scrollbar_layer);
layer_tree_host_->SetRootLayer(layer_tree_root);
UpdateDrawProperties(layer_tree_host_.get());
scrollbar_layer->SetIsDrawable(true);
scrollbar_layer->SetBounds(gfx::Size(100, 100));
layer_tree_root->SetScrollable(gfx::Size(100, 200));
layer_tree_root->SetScrollOffset(gfx::PointF(10, 20));
layer_tree_root->SetBounds(gfx::Size(100, 200));
content_layer->SetBounds(gfx::Size(100, 200));
testing::Mock::VerifyAndClearExpectations(layer_tree_host_.get());
EXPECT_EQ(scrollbar_layer->layer_tree_host(), layer_tree_host_.get());
for (int update_counter = 0; update_counter < num_updates; update_counter++)
scrollbar_layer->Update();
// A non-solid-color scrollbar should have requested two textures.
EXPECT_EQ(expected_resources, fake_ui_resource_manager_->UIResourceCount());
EXPECT_EQ(expected_created,
fake_ui_resource_manager_->TotalUIResourceCreated());
EXPECT_EQ(expected_deleted,
fake_ui_resource_manager_->TotalUIResourceDeleted());
testing::Mock::VerifyAndClearExpectations(layer_tree_host_.get());
}
};
TEST_F(ScrollbarLayerTestResourceCreationAndRelease, ResourceUpload) {
bool use_solid_color_scrollbars = false;
TestResourceUpload(0, 0, 0, 0, use_solid_color_scrollbars);
int num_updates[3] = {1, 5, 10};
int created = 0;
int deleted = 0;
for (int j = 0; j < 3; j++) {
created += num_updates[j] * 2;
deleted = created - 2;
TestResourceUpload(num_updates[j], 2, created, deleted,
use_solid_color_scrollbars);
}
}
TEST_F(ScrollbarLayerTestResourceCreationAndRelease,
SolidColorNoResourceUpload) {
bool use_solid_color_scrollbars = true;
TestResourceUpload(0, 0, 0, 0, use_solid_color_scrollbars);
TestResourceUpload(1, 0, 0, 0, use_solid_color_scrollbars);
}
TEST_F(ScrollbarLayerTestResourceCreationAndRelease, TestResourceUpdate) {
gfx::Point scrollbar_location(0, 185);
scoped_refptr<Layer> layer_tree_root = Layer::Create();
scoped_refptr<Layer> content_layer = Layer::Create();
scoped_refptr<FakePaintedScrollbarLayer> scrollbar_layer =
FakePaintedScrollbarLayer::Create(false, true,
layer_tree_root->element_id());
layer_tree_root->AddChild(content_layer);
layer_tree_root->AddChild(scrollbar_layer);
layer_tree_host_->SetRootLayer(layer_tree_root);
UpdateDrawProperties(layer_tree_host_.get());
scrollbar_layer->SetIsDrawable(true);
scrollbar_layer->SetBounds(gfx::Size(100, 15));
scrollbar_layer->SetPosition(gfx::PointF(scrollbar_location));
layer_tree_root->SetBounds(gfx::Size(100, 200));
content_layer->SetBounds(gfx::Size(100, 200));
testing::Mock::VerifyAndClearExpectations(layer_tree_host_.get());
EXPECT_EQ(scrollbar_layer->layer_tree_host(), layer_tree_host_.get());
size_t resource_count;
int expected_created, expected_deleted;
resource_count = 2;
expected_created = 2;
expected_deleted = 0;
EXPECT_TRUE(scrollbar_layer->Update());
EXPECT_NE(0, scrollbar_layer->track_resource_id());
EXPECT_NE(0, scrollbar_layer->thumb_resource_id());
EXPECT_EQ(resource_count, fake_ui_resource_manager_->UIResourceCount());
EXPECT_EQ(expected_created,
fake_ui_resource_manager_->TotalUIResourceCreated());
EXPECT_EQ(expected_deleted,
fake_ui_resource_manager_->TotalUIResourceDeleted());
resource_count = 0;
expected_created = 2;
expected_deleted = 2;
scrollbar_layer->SetBounds(gfx::Size(0, 0));
scrollbar_layer->fake_scrollbar()->set_track_rect(gfx::Rect(0, 0, 0, 0));
EXPECT_TRUE(scrollbar_layer->Update());
EXPECT_EQ(0, scrollbar_layer->track_resource_id());
EXPECT_EQ(0, scrollbar_layer->thumb_resource_id());
EXPECT_EQ(resource_count, fake_ui_resource_manager_->UIResourceCount());
EXPECT_EQ(expected_created,
fake_ui_resource_manager_->TotalUIResourceCreated());
EXPECT_EQ(expected_deleted,
fake_ui_resource_manager_->TotalUIResourceDeleted());
resource_count = 0;
expected_created = 2;
expected_deleted = 2;
scrollbar_layer->fake_scrollbar()->set_track_rect(gfx::Rect(0, 0, 0, 0));
EXPECT_FALSE(scrollbar_layer->Update());
EXPECT_EQ(0, scrollbar_layer->track_resource_id());
EXPECT_EQ(0, scrollbar_layer->thumb_resource_id());
EXPECT_EQ(resource_count, fake_ui_resource_manager_->UIResourceCount());
EXPECT_EQ(expected_created,
fake_ui_resource_manager_->TotalUIResourceCreated());
EXPECT_EQ(expected_deleted,
fake_ui_resource_manager_->TotalUIResourceDeleted());
resource_count = 2;
expected_created = 4;
expected_deleted = 2;
scrollbar_layer->SetBounds(gfx::Size(100, 15));
scrollbar_layer->fake_scrollbar()->set_track_rect(gfx::Rect(30, 10, 50, 10));
EXPECT_TRUE(scrollbar_layer->Update());
EXPECT_NE(0, scrollbar_layer->track_resource_id());
EXPECT_NE(0, scrollbar_layer->thumb_resource_id());
EXPECT_EQ(resource_count, fake_ui_resource_manager_->UIResourceCount());
EXPECT_EQ(expected_created,
fake_ui_resource_manager_->TotalUIResourceCreated());
EXPECT_EQ(expected_deleted,
fake_ui_resource_manager_->TotalUIResourceDeleted());
resource_count = 1;
expected_created = 5;
expected_deleted = 4;
scrollbar_layer->fake_scrollbar()->set_has_thumb(false);
EXPECT_TRUE(scrollbar_layer->Update());
EXPECT_NE(0, scrollbar_layer->track_resource_id());
EXPECT_EQ(0, scrollbar_layer->thumb_resource_id());
EXPECT_EQ(resource_count, fake_ui_resource_manager_->UIResourceCount());
EXPECT_EQ(expected_created,
fake_ui_resource_manager_->TotalUIResourceCreated());
EXPECT_EQ(expected_deleted,
fake_ui_resource_manager_->TotalUIResourceDeleted());
resource_count = 0;
expected_created = 5;
expected_deleted = 5;
scrollbar_layer->SetBounds(gfx::Size(0, 0));
scrollbar_layer->fake_scrollbar()->set_track_rect(gfx::Rect(0, 0, 0, 0));
EXPECT_TRUE(scrollbar_layer->Update());
EXPECT_EQ(0, scrollbar_layer->track_resource_id());
EXPECT_EQ(0, scrollbar_layer->thumb_resource_id());
EXPECT_EQ(resource_count, fake_ui_resource_manager_->UIResourceCount());
EXPECT_EQ(expected_created,
fake_ui_resource_manager_->TotalUIResourceCreated());
EXPECT_EQ(expected_deleted,
fake_ui_resource_manager_->TotalUIResourceDeleted());
resource_count = 2;
expected_created = 7;
expected_deleted = 5;
scrollbar_layer->SetBounds(gfx::Size(100, 15));
scrollbar_layer->fake_scrollbar()->set_track_rect(gfx::Rect(30, 10, 50, 10));
scrollbar_layer->fake_scrollbar()->set_has_thumb(true);
EXPECT_TRUE(scrollbar_layer->Update());
EXPECT_NE(0, scrollbar_layer->track_resource_id());
EXPECT_NE(0, scrollbar_layer->thumb_resource_id());
resource_count = 2;
expected_created = 9;
expected_deleted = 7;
scrollbar_layer->fake_scrollbar()->set_track_rect(gfx::Rect(0, 0, 0, 0));
EXPECT_TRUE(scrollbar_layer->Update());
EXPECT_NE(0, scrollbar_layer->track_resource_id());
EXPECT_NE(0, scrollbar_layer->thumb_resource_id());
EXPECT_EQ(resource_count, fake_ui_resource_manager_->UIResourceCount());
EXPECT_EQ(expected_created,
fake_ui_resource_manager_->TotalUIResourceCreated());
EXPECT_EQ(expected_deleted,
fake_ui_resource_manager_->TotalUIResourceDeleted());
resource_count = 1;
expected_created = 10;
expected_deleted = 9;
scrollbar_layer->fake_scrollbar()->set_track_rect(gfx::Rect(30, 10, 50, 10));
scrollbar_layer->fake_scrollbar()->set_has_thumb(false);
scrollbar_layer->SetBounds(gfx::Size(90, 15));
EXPECT_TRUE(scrollbar_layer->Update());
EXPECT_EQ(resource_count, fake_ui_resource_manager_->UIResourceCount());
EXPECT_EQ(expected_created,
fake_ui_resource_manager_->TotalUIResourceCreated());
EXPECT_EQ(expected_deleted,
fake_ui_resource_manager_->TotalUIResourceDeleted());
EXPECT_EQ(gfx::Size(90, 15), fake_ui_resource_manager_->ui_resource_size(
scrollbar_layer->track_resource_id()));
// Simulate commit to compositor thread.
scrollbar_layer->PushPropertiesTo(
scrollbar_layer->CreateLayerImpl(layer_tree_host_->active_tree()).get(),
*layer_tree_host_->GetPendingCommitState(),
layer_tree_host_->GetThreadUnsafeCommitState());
scrollbar_layer->fake_scrollbar()->set_needs_repaint_thumb(false);
scrollbar_layer->fake_scrollbar()->set_needs_repaint_track(false);
EXPECT_FALSE(scrollbar_layer->Update());
EXPECT_NE(0, scrollbar_layer->track_resource_id());
EXPECT_EQ(0, scrollbar_layer->thumb_resource_id());
EXPECT_EQ(resource_count, fake_ui_resource_manager_->UIResourceCount());
EXPECT_EQ(expected_created,
fake_ui_resource_manager_->TotalUIResourceCreated());
EXPECT_EQ(expected_deleted,
fake_ui_resource_manager_->TotalUIResourceDeleted());
testing::Mock::VerifyAndClearExpectations(layer_tree_host_.get());
}
class ScaledScrollbarLayerTestResourceCreation : public ScrollbarLayerTest {
public:
void TestResourceUpload(float test_scale) {
gfx::Point scrollbar_location(0, 185);
scoped_refptr<Layer> layer_tree_root = Layer::Create();
scoped_refptr<Layer> content_layer = Layer::Create();
scoped_refptr<FakePaintedScrollbarLayer> scrollbar_layer =
FakePaintedScrollbarLayer::Create(false, true,
layer_tree_root->element_id());
layer_tree_root->AddChild(content_layer);
layer_tree_root->AddChild(scrollbar_layer);
layer_tree_host_->SetRootLayer(layer_tree_root);
scrollbar_layer->SetIsDrawable(true);
scrollbar_layer->SetBounds(gfx::Size(100, 15));
scrollbar_layer->SetPosition(gfx::PointF(scrollbar_location));
layer_tree_root->SetBounds(gfx::Size(100, 200));
content_layer->SetBounds(gfx::Size(100, 200));
EXPECT_EQ(scrollbar_layer->layer_tree_host(), layer_tree_host_.get());
UpdateDrawProperties(layer_tree_host_.get());
layer_tree_host_->SetViewportRectAndScale(
layer_tree_host_->device_viewport_rect(), test_scale,
layer_tree_host_->local_surface_id_from_parent());
scrollbar_layer->Update();
// Verify that we have not generated any content uploads that are larger
// than their destination textures.
gfx::Size track_size = fake_ui_resource_manager_->ui_resource_size(
scrollbar_layer->track_resource_id());
gfx::Size thumb_size = fake_ui_resource_manager_->ui_resource_size(
scrollbar_layer->thumb_resource_id());
EXPECT_LE(track_size.width(),
scrollbar_layer->internal_content_bounds().width());
EXPECT_LE(track_size.height(),
scrollbar_layer->internal_content_bounds().height());
EXPECT_LE(thumb_size.width(),
scrollbar_layer->internal_content_bounds().width());
EXPECT_LE(thumb_size.height(),
scrollbar_layer->internal_content_bounds().height());
}
};
TEST_F(ScaledScrollbarLayerTestResourceCreation, ScaledResourceUpload) {
// Pick a test scale that moves the scrollbar's (non-zero) position to
// a non-pixel-aligned location.
TestResourceUpload(.041f);
TestResourceUpload(1.41f);
TestResourceUpload(4.1f);
// Try something extreme to be larger than max texture size, and make it a
// non-integer for funsies.
scoped_refptr<viz::TestContextProvider> context =
viz::TestContextProvider::Create();
// Keep the max texture size reasonable so we don't OOM on low end devices
// (crbug.com/642333).
context->UnboundTestContextGL()->set_max_texture_size(512);
context->BindToCurrentSequence();
int max_texture_size = 0;
context->ContextGL()->GetIntegerv(GL_MAX_TEXTURE_SIZE, &max_texture_size);
EXPECT_EQ(512, max_texture_size);
TestResourceUpload(max_texture_size / 9.9f);
}
class ScaledScrollbarLayerTestScaledRasterization : public ScrollbarLayerTest {
public:
void TestScale(const gfx::Rect& scrollbar_rect, float test_scale) {
bool paint_during_update = true;
bool has_thumb = false;
scoped_refptr<Layer> layer_tree_root = Layer::Create();
scoped_refptr<FakePaintedScrollbarLayer> scrollbar_layer =
FakePaintedScrollbarLayer::Create(paint_during_update, has_thumb,
layer_tree_root->element_id());
layer_tree_root->AddChild(scrollbar_layer);
layer_tree_host_->SetRootLayer(layer_tree_root);
scrollbar_layer->SetBounds(scrollbar_rect.size());
scrollbar_layer->SetPosition(gfx::PointF(scrollbar_rect.origin()));
scrollbar_layer->fake_scrollbar()->set_track_rect(
gfx::Rect(scrollbar_rect.size()));
layer_tree_host_->SetViewportRectAndScale(
layer_tree_host_->device_viewport_rect(), test_scale,
layer_tree_host_->local_surface_id_from_parent());
UpdateDrawProperties(layer_tree_host_.get());
scrollbar_layer->Update();
UIResourceBitmap* bitmap = fake_ui_resource_manager_->ui_resource_bitmap(
scrollbar_layer->track_resource_id());
DCHECK(bitmap);
const SkColor* pixels =
reinterpret_cast<const SkColor*>(bitmap->GetPixels());
SkColor color = argb_to_skia(
scrollbar_layer->fake_scrollbar()->paint_fill_color());
int width = bitmap->GetSize().width();
int height = bitmap->GetSize().height();
// Make sure none of the corners of the bitmap were inadvertently clipped.
EXPECT_EQ(color, pixels[0])
<< "Top left pixel doesn't match scrollbar color.";
EXPECT_EQ(color, pixels[width - 1])
<< "Top right pixel doesn't match scrollbar color.";
EXPECT_EQ(color, pixels[width * (height - 1)])
<< "Bottom left pixel doesn't match scrollbar color.";
EXPECT_EQ(color, pixels[width * height - 1])
<< "Bottom right pixel doesn't match scrollbar color.";
}
protected:
// On Android, Skia uses ABGR
static SkColor argb_to_skia(SkColor c) {
return (SkColorGetA(c) << SK_A32_SHIFT) |
(SkColorGetR(c) << SK_R32_SHIFT) |
(SkColorGetG(c) << SK_G32_SHIFT) |
(SkColorGetB(c) << SK_B32_SHIFT);
}
};
TEST_F(ScaledScrollbarLayerTestScaledRasterization, TestLostPrecisionInClip) {
// Try rasterization at coordinates and scale that caused problematic
// rounding and clipping errors.
// Vertical Scrollbars.
TestScale(gfx::Rect(1240, 0, 15, 1333), 2.7754839f);
TestScale(gfx::Rect(1240, 0, 15, 677), 2.46677136f);
// Horizontal Scrollbars.
TestScale(gfx::Rect(0, 1240, 1333, 15), 2.7754839f);
TestScale(gfx::Rect(0, 1240, 677, 15), 2.46677136f);
}
} // namespace cc
| [
"[email protected]"
] | |
433e64e6cb53b336617d5403a53014a55c3a3640 | df9683e18f6e5f501981f1254a26c95c9c93963f | /Dependencies/rttr/src/rttr/property.cpp | fef49f6c1cc32f8c4709b71e30d7ce1fcb25557a | [
"MIT"
] | permissive | riverreal/ShaftEngine | d112b73467d49bc24d7f1bd8694100dd0576a829 | 3ff3bb7395eece75f645521c97b309391284fb94 | refs/heads/master | 2021-04-26T22:25:41.266553 | 2020-01-28T14:01:25 | 2020-01-28T14:01:25 | 124,089,617 | 5 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 6,185 | cpp | /************************************************************************************
* *
* Copyright (c) 2014 - 2018 Axel Menzel <[email protected]> *
* *
* This file is part of RTTR (Run Time Type Reflection) *
* License: MIT License *
* *
* 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 "rttr/property.h"
#include "rttr/detail/property/property_wrapper_base.h"
#include "rttr/variant.h"
#include "rttr/argument.h"
#include "rttr/instance.h"
#include "rttr/enumeration.h"
using namespace std;
namespace rttr
{
namespace detail
{
template<>
property create_item(const property_wrapper_base* wrapper)
{
return property(wrapper);
}
template<>
property create_invalid_item()
{
static const detail::property_wrapper_base invalid_wrapper(string_view(), detail::get_invalid_type());
return property(&invalid_wrapper);
}
} // end namespace detail;
/////////////////////////////////////////////////////////////////////////////////////////
property::property(const detail::property_wrapper_base* wrapper) RTTR_NOEXCEPT
: m_wrapper(wrapper)
{
}
/////////////////////////////////////////////////////////////////////////////////////////
bool property::is_valid() const RTTR_NOEXCEPT
{
return m_wrapper->is_valid();
}
/////////////////////////////////////////////////////////////////////////////////////////
property::operator bool() const RTTR_NOEXCEPT
{
return m_wrapper->is_valid();
}
/////////////////////////////////////////////////////////////////////////////////////////
access_levels property::get_access_level() const RTTR_NOEXCEPT
{
return m_wrapper->get_access_level();
}
/////////////////////////////////////////////////////////////////////////////////////////
bool property::is_readonly() const RTTR_NOEXCEPT
{
return m_wrapper->is_readonly();
}
/////////////////////////////////////////////////////////////////////////////////////////
bool property::is_static() const RTTR_NOEXCEPT
{
return m_wrapper->is_static();
}
/////////////////////////////////////////////////////////////////////////////////////////
bool property::is_enumeration() const RTTR_NOEXCEPT
{
return m_wrapper->get_type().is_enumeration();
}
/////////////////////////////////////////////////////////////////////////////////////////
enumeration property::get_enumeration() const RTTR_NOEXCEPT
{
return m_wrapper->get_type().get_enumeration();
}
/////////////////////////////////////////////////////////////////////////////////////////
bool property::is_array() const RTTR_NOEXCEPT
{
return m_wrapper->is_array();
}
/////////////////////////////////////////////////////////////////////////////////////////
string_view property::get_name() const RTTR_NOEXCEPT
{
return m_wrapper->get_name();
}
/////////////////////////////////////////////////////////////////////////////////////////
type property::get_type() const RTTR_NOEXCEPT
{
return m_wrapper->get_type();
}
/////////////////////////////////////////////////////////////////////////////////////////
type property::get_declaring_type() const RTTR_NOEXCEPT
{
return m_wrapper->get_declaring_type();
}
/////////////////////////////////////////////////////////////////////////////////////////
bool property::set_value(instance object, argument arg) const
{
return m_wrapper->set_value(object, arg);
}
/////////////////////////////////////////////////////////////////////////////////////////
variant property::get_value(instance object) const
{
return m_wrapper->get_value(object);
}
/////////////////////////////////////////////////////////////////////////////////////////
variant property::get_metadata(const variant& key) const
{
return m_wrapper->get_metadata(key);
}
/////////////////////////////////////////////////////////////////////////////////////////
bool property::operator==(const property& other) const RTTR_NOEXCEPT
{
return (m_wrapper == other.m_wrapper);
}
/////////////////////////////////////////////////////////////////////////////////////////
bool property::operator!=(const property& other) const RTTR_NOEXCEPT
{
return (m_wrapper != other.m_wrapper);
}
/////////////////////////////////////////////////////////////////////////////////////////
} // end namespace rttr
| [
"[email protected]"
] | |
f13e943ac9b0af542034410f00b31154e59bca61 | 693ef6e7fb51dcffbede887a56884f653d9022bd | /OJ/POJ/POJ_DS_JS03.cpp | 82bb9aa7a497b00fab0f31474deaea0dbaa358c5 | [] | no_license | kumasento/VELVET-PROGRAMMING | e56a2950445cedfbe25cf06c19a0ea1d2924424d | 14620f7a738b085606d6bd9262f1e4a933ddaeaa | refs/heads/master | 2020-12-31T06:32:10.537694 | 2015-10-27T14:33:12 | 2015-10-27T14:33:12 | 26,422,804 | 2 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 1,352 | cpp | #include <iostream>
#include <cstring>
#include <cstdlib>
#include <cstdio>
#include <cmath>
#include <algorithm>
using namespace std;
int Find(int a, int p[], int r[]){
int R = 0; int t = a;
while(a!=p[a]){
R += r[a];
a = p[a];
}
p[t] = p[a];
r[t] = R%2;
return a;
}
void Union(int ra, int rb, int p[]){
p[rb] = ra;
return;
}
int main(){
freopen("data_js03.in","r",stdin);
int T; scanf("%d", &T);
while(T--){
int N, M; scanf("%d%d", &N, &M);
int p[N+1]; memset(p,0,sizeof(p));
for(int i = 1; i <= N; i++) p[i] = i;
int r[N+1]; memset(r,0,sizeof(r));
while(M--){
char st[100]; scanf("%s", st);
if(st[0] == 'D'){
int a, b; scanf("%d%d", &a, &b);
int pa = Find(a,p,r), pb = Find(b,p,r);
Union(pa,pb,p);
r[pb] = (r[a]+r[b]+1)%2;
}
else if(st[0] == 'A'){
int a, b; scanf("%d%d", &a, &b);
int pa = Find(a,p,r), pb = Find(b,p,r);
if(pa == pb){
if(r[a] == r[b])
printf("In the same gang.\n");
else
printf("In different gangs.\n");
}
else
printf("Not sure yet.\n");
}
/*
for( int i = 1; i <= N; i++ )
cout << p[i] <<' ';
cout << endl;
for( int i = 1; i <= N; i++ )
cout << Find(i,p,r) <<' ';
cout << endl;
for( int i = 1; i <= N; i++ )
cout << r[i] <<' ';
cout << endl;
cout << endl;
*/
}
}
return 0;
} | [
"[email protected]"
] | |
a6e3056f7425a336e3691bbedf9a5d2ed552f5be | bd5a80abcf3dd43a1e92ac965b4e282e149ddbea | /api/http/cpp/client.h | 09181d6fa253ca177c9a05b8c6b8b9376fb1710f | [
"BSD-3-Clause"
] | permissive | apprivoiser/gStoreD | 5e8602a0cd6182aa7a0530cba29d79e446bfc8e5 | 78bf412296a06048292f39fabd0968509496adba | refs/heads/master | 2021-06-27T19:36:15.254140 | 2020-12-31T06:35:27 | 2020-12-31T06:35:27 | 262,071,712 | 1 | 1 | null | null | null | null | GB18030 | C++ | false | false | 3,615 | h | /*
# Filename: client.h
# Author: suxunbin
# Last Modified: 2019-5-17 14:56
# Description: http api for C++
*/
#ifndef __HTTP_CURL_H__
#define __HTTP_CURL_H__
//REFERENCE: https://curl.haxx.se/
//libcurl is useful for developing http client, but not for server
//
//TODO: deal with cookie
//URL encode: http://www.ruanyifeng.com/blog/2010/02/url_encoding.html
#include <string>
class GstoreConnector
{
public:
std::string serverIP;
int serverPort;
std::string Url;
std::string username;
std::string password;
GstoreConnector(void);
GstoreConnector(std::string _ip, int _port, std::string _user, std::string _passwd);
~GstoreConnector(void);
public:
/**
* @brief HTTP POST请求
* @param strUrl 输入参数,请求的Url地址,如:http://www.baidu.com
* @param strPost 输入参数,使用如下格式para1=val1?2=val2&…
* @param strResponse 输出参数,返回的内容
* @return 返回是否Post成功
*/
int Post(const std::string & strUrl, const std::string & strPost, const std::string & filename, bool SavedOnFile);
int Post(const std::string & strUrl, const std::string & strPost, std::string & strResponse);
/**
* @brief HTTP GET请求
* @param strUrl 输入参数,请求的Url地址,如:http://www.baidu.com
* @param strResponse 输出参数,返回的内容
* @return 返回是否Post成功
*/
int Get(const std::string & strUrl, const std::string & filename, bool SavedOnFile);
int Get(const std::string & strUrl, std::string & strResponse);
/**
* @brief HTTPS POST请求,无证书版本
* @param strUrl 输入参数,请求的Url地址,如:https://www.alipay.com
* @param strPost 输入参数,使用如下格式para1=val1?2=val2&…
* @param strResponse 输出参数,返回的内容
* @param pCaPath 输入参数,为CA证书的路径.如果输入为NULL,则不验证服务器端证书的有效性.
* @return 返回是否Post成功
*/
int Posts(const std::string & strUrl, const std::string & strPost, std::string & strResponse, const char * pCaPath = NULL);
/**
* @brief HTTPS GET请求,无证书版本
* @param strUrl 输入参数,请求的Url地址,如:https://www.alipay.com
* @param strResponse 输出参数,返回的内容
* @param pCaPath 输入参数,为CA证书的路径.如果输入为NULL,则不验证服务器端证书的有效性.
* @return 返回是否Post成功
*/
int Gets(const std::string & strUrl, std::string & strResponse, const char * pCaPath = NULL);
public:
std::string build(std::string db_name, std::string rdf_file_path, std::string request_type = "GET");
std::string load(std::string db_name, std::string request_type = "GET");
std::string unload(std::string db_name, std::string request_type = "GET");
std::string user(std::string type, std::string username2, std::string addition, std::string request_type = "GET");
std::string showUser(std::string request_type = "GET");
std::string query(std::string db_name, std::string format, std::string sparql, std::string request_type = "GET");
void fquery(std::string db_name, std::string format, std::string sparql, std::string filename, std::string request_type = "GET");
std::string drop(std::string db_name, bool is_backup, std::string request_type = "GET");
std::string monitor(std::string db_name, std::string request_type = "GET");
std::string checkpoint(std::string db_name, std::string request_type = "GET");
std::string show(std::string request_type = "GET");
std::string getCoreVersion(std::string request_type = "GET");
std::string getAPIVersion(std::string request_type = "GET");
void SetDebug(bool bDebug);
private:
bool m_bDebug;
};
#endif
| [
"[email protected]"
] | |
2fad6643ae9c4886475c36aea0435dcd61bfded3 | addb2ea780b5c3d365019ccc2318794a66bd2e7c | /src/robot_action/myrobot.cpp | ebc470ee10631c45275c88ad33c9312f120539eb | [
"Apache-2.0"
] | permissive | resizoltan/robot_action | be9ae6965098982456508a75a40fbfa17f7b7a07 | 8e90db7875bb6840fef57aec002213e85319a5da | refs/heads/master | 2020-06-24T16:29:42.892261 | 2019-07-30T09:45:36 | 2019-07-30T09:45:36 | 199,016,189 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,976 | cpp | /*
* myrobot.cpp
*
* Created on: Jul 26, 2019
* Author: kukauser
*/
#include "robot_action/myrobot.h"
#include <sstream>
#include <mutex>
#include <iostream>
#include <cmath>
using namespace robot_action;
MyRobot::MyRobot():
name_("Noname Robot"),
current_position_(0.0),
commanded_position_(0.0),
velocity_(1.0),
commanding_active_(false),
feedback_period_seconds_(1),
step_callback_([](double dummy){}),
position_reached_callback_([](double dummy){})
{
}
MyRobot::MyRobot(std::string name):
MyRobot()
{
name_ = name;
}
std::string MyRobot::GetName()
{
return name_;
}
void MyRobot::MoveToPosition(double commanded_position)
{
commanded_position_ = commanded_position;
if(!commanding_active_)
{
commanding_active_ = true;
simulation_thread_ = std::thread(&MyRobot::SimulateMovement, this);
simulation_thread_.detach();
}
}
void MyRobot::SimulateMovement()
{
const double resolution_ms = 10;
int32_t tick_count = 0;
std::stringstream ss;
do{
std::this_thread::sleep_for(std::chrono::milliseconds(static_cast<int>(resolution_ms)));
mu_.lock();
double direction = commanded_position_ > current_position_ ? 1 : -1;
current_position_ += direction*velocity_/1000*resolution_ms;
if(++tick_count >= feedback_period_seconds_*1000/resolution_ms)
{
step_callback_(current_position_);
tick_count = 0;
}
mu_.unlock();
}while(fabs(commanded_position_ - current_position_) >= (velocity_/1000*resolution_ms));
mu_.lock();
position_reached_callback_(current_position_);
commanding_active_ = false;
mu_.unlock();
}
void MyRobot::SetStepCallback(std::function<void(double)> callback)
{
step_callback_ = callback;
}
void MyRobot::SetPositionReachedCallback(std::function<void(double)> callback)
{
position_reached_callback_ = callback;
}
void MyRobot::SetFeedbackPeriod(int32_t period_seconds)
{
feedback_period_seconds_ = period_seconds;
}
| [
"[email protected]"
] | |
97a0dbec729b405b101392744a61e34df2a3d60e | b06578218c2dcc385300ff559b468597b22b124c | /engine/include/MM/MMPlayer.h | b282f27d5ee6f7ee72a252805567ec32bb0b95ff | [] | no_license | suratovvlad/bubblegame | 8f5be03e6034157ee8316295bfcb39d051267e08 | f489c3ee3a837686712369dff8679371e555341c | refs/heads/master | 2020-07-21T20:47:54.839139 | 2016-11-16T12:12:41 | 2016-11-16T12:12:41 | 73,841,231 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,397 | h | #pragma once
#include "Render/Texture.h"
class TheoraVideoManager;
class TheoraAudioInterfaceFactory;
class TheoraVideoClip;
namespace MM {
/// Проигрыватель видео файлов
class MMPlayer
{
public:
MMPlayer(const std::string& filename, bool loop = false, bool vsync = false, bool cacheToMemory = false);
~MMPlayer();
void FadeInTrack(float s);
void FadeOutTrack(float s);
void SetVolume(float volume);
float GetVolume() const;
void Play();
bool IsPlaying() const;
void Pause(bool pause);
void Rewind();
void Stop();
float GetDuration() const;
float GetTimePosition() const;
void Seek(float time_position);
bool Finished() const;
void Update(float dt);
void Draw(int x, int y, int width, int height);
Render::Texture* GetVideoTexture() const { return _video.get(); }
private:
std::string _filename;
bool _loop;
bool _vsync;
static boost::shared_ptr<TheoraVideoManager> sharedMgr;
boost::shared_ptr<TheoraVideoManager> _mgr;
boost::scoped_ptr<Render::Texture> _video;
TheoraVideoClip* _clip;
bool _fadeIn;
bool _fadeOut;
float _fadeInTime;
float _fadeOutTime;
float _fadeLength;
float _fadeVolume;
bool _cacheToMemory;
private:
// Запретить копирование и присваивание
MMPlayer(const MMPlayer&);
MMPlayer& operator=(const MMPlayer&);
void Open();
void Close();
};
} // namespace MM
| [
"[email protected]"
] | |
0e029fd4df807fa828e7f64ad171d1c1da5f613e | 3dae85df94e05bb1f3527bca0d7ad413352e49d0 | /ml/nn/runtime/test/generated/tests/argmin_3_float.mod.py.cpp | f2de4247556d7855cea08eeb4129b4980abb9d08 | [
"Apache-2.0"
] | permissive | Wenzhao-Xiang/webml-wasm | e48f4cde4cb986eaf389edabe78aa32c2e267cb9 | 0019b062bce220096c248b1fced09b90129b19f9 | refs/heads/master | 2020-04-08T11:57:07.170110 | 2018-11-29T07:21:37 | 2018-11-29T07:21:37 | 159,327,152 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 511 | cpp | // clang-format off
// Generated file (from: argmin_3_float.mod.py). Do not edit
#include "../../TestGenerated.h"
namespace argmin_3_float {
// Generated argmin_3_float test
#include "generated/examples/argmin_3_float.example.cpp"
// Generated model constructor
#include "generated/models/argmin_3_float.model.cpp"
} // namespace argmin_3_float
TEST_F(GeneratedTests, argmin_3_float) {
execute(argmin_3_float::CreateModel,
argmin_3_float::is_ignored,
argmin_3_float::examples);
}
| [
"[email protected]"
] | |
55500c27fe4fdbe6641ef728c9b8bc3a4e242221 | 91f24b7eaa61ff8cdf3688df4d42e080bdc172df | /Tic Tac Toe Mini Game.CPP | 8477674b93880bd933abd3e7733804a92d3276fa | [] | no_license | somesh6797/MiniProjects | be7384d70c76b9a3a57e2606efc47c9ea956cd93 | 771db986f01fc69a9857352127ec3452a47e1c2e | refs/heads/master | 2021-01-08T22:00:33.627865 | 2020-03-14T04:30:39 | 2020-03-14T04:30:39 | 242,150,963 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 7,457 | cpp | #include<conio.h>
#include<iostream.h>
#include<stdlib.h>
#include<stdio.h>
void play();
void check(char &,int &,char &,char &);
void getv(char &,char &,char &);
void startgame(char &,char &);
void pname(char &,char &);
void win1(char &,int &);
void win2(char &,int &);
void or(char &,char &);
void disp(char &);
void def(char &);
void send(char &a,char &b,char &c,int &z1,char p1[],char p2[]);
void endgame();
void start();
void strct();
void line();
void s();
inline void uphor (char ar[],char &aa,char &bb,char &cc)
{aa=ar[0],bb=ar[1],cc=ar[2];}
inline void midhor(char ar[],char &aa,char &bb,char &cc)
{aa=ar[3],bb=ar[4],cc=ar[5];}
inline void lahor (char ar[],char &aa,char &bb,char &cc)
{aa=ar[6],bb=ar[7],cc=ar[8];}
inline void upver (char ar[],char &aa,char &bb,char &cc)
{aa=ar[0],bb=ar[3],cc=ar[6];}
inline void midver(char ar[],char &aa,char &bb,char &cc)
{aa=ar[1],bb=ar[4],cc=ar[7];}
inline void laver (char ar[],char &aa,char &bb,char &cc)
{aa=ar[2],bb=ar[5],cc=ar[8];}
inline void Ldig (char ar[],char &aa,char &bb,char &cc)
{aa=ar[0],bb=ar[4],cc=ar[8];}
inline void Jdig (char ar[],char &aa,char &bb,char &cc)
{aa=ar[2],bb=ar[4],cc=ar[6];}
void win1(char pr1[],int &zr1 )
{
cout<<"----------------::: Congratulations "<<pr1<<"(o) you won!!! :::-----------------\n";
zr1=1;
getch();
}
void win2(char pr2[],int &zr2 )
{
cout<<"----------------::: Congratulations "<<pr2<<"(x) you won!!! :::-----------------\n";
zr2=1;
getch();
}
void pname(char name1[], char name2[])
{
int ps;
cout<<"\n\t\t Hey players!!.. wanna enter names for player";
cout<<"\n\t\t Yes enter-(1) and for No anything except characters \n\t\t";
cin>>ps;
if(ps==1)
{
cout<<"\n\t\t Enter name for player 1\n\t\t";
cin>>name1;
cout<<"\n\t\t Enter name for player 2\n\t\t";
cin>>name2;
}
}
void s()
{
cout<<"\n";
cout<<"\t\t "<<endl;
cout<<"\t\t "<<endl;
cout<<"\t\t "<<endl;
cout<<"\t\t "<<endl;
cout<<"\t\t "<<endl;
}
void line()
{
for(int i=1;i<=80;i++)
{
cout<<"-";
}
}
void strct()
{
cout<<"\t\t\t a|b|c\n";
cout<<"\t\t\t d|e|f\n";
cout<<"\t\t\t g|h|i\n";
}
void disp(char a1[])
{
cout<<"\n\t\t\t " <<a1[0]<<"|"<<a1[1]<<"|"<<a1[2]<<"\n";
cout<<" \t\t\t " <<a1[3]<<"|"<<a1[4]<<"|"<<a1[5]<<"\n";
cout<<" \t\t\t " <<a1[6]<<"|"<<a1[7]<<"|"<<a1[8]<<"\n\n";
}
void def(char a1[])
{
for(int i=0;i<=8;i++)
{
a1[i]='-';
}
}
void startgame(char namea[10],char nameb[10])
{
//pname(namea,nameb);
for(int i=1;i<=2;i++)
{
for(int j=1;j<=80;j++)
{
cout<<"_";
if(i==2&&j==28)
{
cout<<" Starting of Game!!.....";
j=52;
}
}
cout<<"\n";
}
cout<<"----------------------Please start the Tic Tac Toe Game.------------------------\n";
cout<<" "<<namea<<" is (o) & "<<nameb<<" is (x) \n";
cout<<"________________________________________________________________________________";
cout<<"\n\n\n";
}
void endgame()
{
clrscr();
s();
cout<<"\n\n";
for(int i=1;i<=3;i++)
{
for(int j=1;j<=80;j++)
{
cout<<"_";
if(i==2&&j==28)
{
cout<<" Dead End of Game!!!...";
j=51;
}
}
cout<<"\n";
}
cout<<"-------------------------Thank You for playing game !!--------------------------\n";
cout<<"________________________________________________________________________________";
}
void getv(char &n1,char a1[],char &x1)
{
int i;
char j;
for(i=0,j='a';i<=8,j<='i';i++,j++)
{
if(n1==j)
{
a1[i]=x1;
}
}
}
void or(char &m,char b[],char &p1)
{
int j;
char i;
for(j=0,i='a';j<=8,i<='i';j++,i++)
{
if(m==i)
{
if(b[j]=='x'||b[j]=='o')
{
p1=0;
}
else
p1=1;
}
}
}
void check(char b1[],int &z11,char p11[],char p22[])
{
//calls the states
char a,b,c;
uphor (b1,a,b,c);
send(a,b,c,z11,p11,p22);
midhor(b1,a,b,c);
send(a,b,c,z11,p11,p22);
lahor (b1,a,b,c);
send(a,b,c,z11,p11,p22);
upver (b1,a,b,c);
send(a,b,c,z11,p11,p22);
midver(b1,a,b,c);
send(a,b,c,z11,p11,p22);
laver (b1,a,b,c);
send(a,b,c,z11,p11,p22);
Ldig (b1,a,b,c);
send(a,b,c,z11,p11,p22);
Jdig (b1,a,b,c);
send(a,b,c,z11,p11,p22);
}
void send(char &a,char &b,char &c,int &z1,char p1[],char p2[])
{
if(a==b&&b==c)
{
if(a=='x'||b=='o')
{
if(a=='o')
{
win1(p1,z1);
}
else
{
win2(p2,z1);
}
}
}
}
void start()
{
char n,x,p,a[9];
int z,y;
again: clrscr();
s();//just design purpose
char namep1[10]="Player1",namep2[10]="Player2";
startgame(namep1,namep2);//player details and names
getch();
clrscr();
def(a); //set all the square with the '-'
for(int i=0;i<=8;i++)
{
clrscr();
s();
cout<<"\n\n";
line();// specifyes a horizontal line (design)
cout<<"\n\n\t\t To quit press\"q\"\n ";
strct();// shows positions
disp(a);// shows game current board
check(a,z,namep1,namep2);//
if(z==1)
{
z=2;
cout<<"\n\t\tIf you want to continue to play press 1\n\t\t\t";
cin>>y;
if(y==1)
{
y=2;
goto again;
}
else
endgame();
getch();
exit(0);
}
if(i%2==0)
{
cout<<"\n\t\t"<<namep1<<" (o) Where you want to enter\n\t\t\t";
}
else
{
cout<<"\n\t\t"<<namep2<<" (x) Where you want to enter\n\t\t\t";
}
a: cin>>n;
if(n=='q')
{
clrscr();
endgame();
getch();
exit(0);
}
if(n=='a'||n=='b'||n=='c'||
n=='d'||n=='e'||n=='f'||
n=='g'||n=='h'||n=='i' )
{
or(n,a,p);
if(p==0)
{
gotoxy(17,22);
cout<<"This is cheating enter in other place \n\t\t\t";
goto a;
}
else
{
if(i%2==0)
{
x='o';
}
else
x='x';
}
}
else
{
gotoxy(17,21);
cout<<"\n\t\tEnter valid place value\n\t\t\t";
goto a;
}
getv(n,a,x);
}/* end of for statement*/
cout<<"\n-----------------Oooops!! It's Draw, you both have strong mind.----------------- \n";
cout<<"\n\t\tIf you want to continue to play press 1\n\t\t\t";
cin>>y;
if(y==1)
{
y=2;
goto again;
}
endgame();
}/* end of start() */
void play()
{
start();
}
void main()
{
play();
} | [
"[email protected]"
] | |
d4e6f9f11ca7ba1a952b4a180528ef3a4dad7866 | 3103580e0fa02ba141e9ec7f1d8868f70fc0f1b7 | /gbplanner/src/rrg.cpp | c3d0e5c761037e02a2b7f674dbb71cd8319ad51e | [
"BSD-3-Clause"
] | permissive | ArghyaChatterjee/gbplanner_ros | dce0fb35997c3cbb19317eae230810fd683e5cc1 | b198ca47b9ec6b88b9b620606f079b4c2053be01 | refs/heads/master | 2022-11-13T01:01:20.107034 | 2020-07-07T06:17:31 | 2020-07-07T06:17:31 | 278,187,055 | 1 | 0 | null | 2020-07-08T20:22:11 | 2020-07-08T20:22:10 | null | UTF-8 | C++ | false | false | 148,876 | cpp | #include "gbplanner/rrg.h"
#include <pcl/common/transforms.h>
#include <tf/transform_listener.h>
#define SQ(x) (x * x)
namespace explorer {
namespace gbplanner {
Rrg::Rrg(const ros::NodeHandle& nh, const ros::NodeHandle& nh_private)
: nh_(nh), nh_private_(nh_private) {
#ifdef USE_OCTOMAP
map_manager_ = new MapManagerOctomap(nh_, nh_private_);
#else
map_manager_ =
new MapManagerVoxblox<MapManagerVoxbloxServer, MapManagerVoxbloxVoxel>(
nh_, nh_private_);
#endif
visualization_ = new Visualization(nh_, nh_private_);
geofence_manager_.reset(new GeofenceManager());
// Initialize graphs.
global_graph_.reset(new GraphManager());
//
robot_state_hist_.reset(new RobotStateHistory());
// Others.
stat_.reset(new SampleStatistic());
planner_trigger_time_ = 0;
current_battery_time_remaining_ = std::numeric_limits<double>::max();
rostime_start_ = ros::Time::now();
//
exploring_direction_ = 0.0;
periodic_timer_ =
nh_.createTimer(ros::Duration(kTimerPeriod), &Rrg::timerCallback, this);
odometry_ready = false;
last_state_marker_ << 0, 0, 0, 0;
last_state_marker_global_ << 0, 0, 0, 0;
robot_backtracking_prev_ = NULL;
free_cloud_pub_ =
nh_.advertise<sensor_msgs::PointCloud2>("freespace_pointcloud", 10);
//
global_graph_update_timer_ =
nh_.createTimer(ros::Duration(kGlobalGraphUpdateTimerPeriod),
&Rrg::expandGlobalGraphTimerCallback, this);
free_pointcloud_update_timer_ =
nh_.createTimer(ros::Duration(kFreePointCloudUpdatePeriod),
&Rrg::freePointCloudtimerCallback, this);
}
void Rrg::reset() {
// Reset the local graph.
local_graph_.reset(new GraphManager());
local_graph_rep_.reset();
// Re-initialize data structs.
stat_.reset(new SampleStatistic());
// Set state for root/source vertex.
StateVec root_state;
if (planning_params_.use_current_state)
root_state = current_state_;
else {
root_state = state_for_planning_;
}
stat_->init(root_state);
// Create a root vertex and add to the graph.
// Root vertex should be assigned id 0.
root_vertex_ = new Vertex(local_graph_->generateVertexID(), root_state);
local_graph_->addVertex(root_vertex_);
if ((planner_trigger_time_ == 0) && (global_graph_->getNumVertices() == 0)) {
// First time trigger the planner. Initialize the root for global graph as
// well.
Vertex* g_root_vertex =
new Vertex(global_graph_->generateVertexID(), root_state);
global_graph_->addVertex(g_root_vertex);
}
// First check if this position is free to go.
MapManager::VoxelStatus voxel_state = map_manager_->getBoxStatus(
Eigen::Vector3d(root_state[0], root_state[1], root_state[2]) +
robot_params_.center_offset,
robot_box_size_, true);
if (MapManager::VoxelStatus::kFree != voxel_state) {
switch (voxel_state) {
case MapManager::VoxelStatus::kFree:
ROS_INFO("Current box is Free.");
break;
case MapManager::VoxelStatus::kOccupied:
ROS_INFO("Current box contains Occupied voxels.");
break;
case MapManager::VoxelStatus::kUnknown:
ROS_INFO("Current box contains Unknown voxels.");
break;
}
// Assume that even it is not fully free, but safe to clear these voxels.
ROS_WARN("Starting position is not clear--> clear space around the robot.");
map_manager_->augmentFreeBox(
Eigen::Vector3d(root_state[0], root_state[1], root_state[2]) +
robot_params_.center_offset,
robot_box_size_);
}
// Clear free space before planning.
if (planning_params_.free_frustum_before_planning) {
map_manager_->augmentFreeFrustum();
}
visualization_->visualizeRobotState(root_vertex_->state, robot_params_);
visualization_->visualizeSensorFOV(root_vertex_->state, sensor_params_);
if (planning_params_.type == PlanningModeType::kVerticalExploration) {
visualization_->visualizeWorkspace(
root_vertex_->state, global_space_params_, local_vertical_params_);
} else {
visualization_->visualizeWorkspace(
root_vertex_->state, global_space_params_, local_space_params_);
}
}
void Rrg::clear() {}
bool Rrg::sampleVertex(StateVec& state) {
bool found = false;
int while_thres = 1000; // magic number
while (!found && while_thres--) {
random_sampler_.generate(root_vertex_->state, state);
// Very fast check if the sampled point is inside the planning space.
// This helps eliminate quickly points outside the sampling space.
if (state.x() + robot_params_.center_offset.x() <
global_space_params_.min_val.x() + 0.5 * robot_box_size_.x()) {
continue;
} else if (state.y() + robot_params_.center_offset.y() <
global_space_params_.min_val.y() + 0.5 * robot_box_size_.y()) {
continue;
} else if (state.z() + robot_params_.center_offset.z() <
global_space_params_.min_val.z() + 0.5 * robot_box_size_.z()) {
continue;
} else if (state.x() + robot_params_.center_offset.x() >
global_space_params_.max_val.x() - 0.5 * robot_box_size_.x()) {
continue;
} else if (state.y() + robot_params_.center_offset.y() >
global_space_params_.max_val.y() - 0.5 * robot_box_size_.y()) {
continue;
} else if (state.z() + robot_params_.center_offset.z() >
global_space_params_.max_val.z() - 0.5 * robot_box_size_.z()) {
continue;
}
// Check if in geofence areas.
if ((planning_params_.geofence_checking_enable) &&
(GeofenceManager::CoordinateStatus::kViolated ==
geofence_manager_->getBoxStatus(
Eigen::Vector2d(state[0] + robot_params_.center_offset[0],
state[1] + robot_params_.center_offset[1]),
Eigen::Vector2d(robot_box_size_[0], robot_box_size_[1]))))
continue;
// Check if surrounding area is free.
if (MapManager::VoxelStatus::kFree ==
map_manager_->getBoxStatus(
Eigen::Vector3d(state[0], state[1], state[2]) +
robot_params_.center_offset,
robot_box_size_, true)) {
random_sampler_.pushSample(state, true); // for debug purpose.
found = true;
} else {
stat_->num_vertices_fail++;
random_sampler_.pushSample(state, false);
}
}
return found;
}
bool Rrg::sampleVertex(RandomSampler& random_sampler, StateVec& root_state,
StateVec& sampled_state) {
bool found = false;
int while_thres = 1000; // magic number.
while (!found && while_thres--) {
random_sampler.generate(root_state, sampled_state);
// Very fast check if the sampled point is inside the planning space.
// This helps eliminate quickly points outside the sampling space.
if (sampled_state.x() + robot_params_.center_offset.x() <
global_space_params_.min_val.x() + 0.5 * robot_box_size_.x()) {
continue;
} else if (sampled_state.y() + robot_params_.center_offset.y() <
global_space_params_.min_val.y() + 0.5 * robot_box_size_.y()) {
continue;
} else if (sampled_state.z() + robot_params_.center_offset.z() <
global_space_params_.min_val.z() + 0.5 * robot_box_size_.z()) {
continue;
} else if (sampled_state.x() + robot_params_.center_offset.x() >
global_space_params_.max_val.x() - 0.5 * robot_box_size_.x()) {
continue;
} else if (sampled_state.y() + robot_params_.center_offset.y() >
global_space_params_.max_val.y() - 0.5 * robot_box_size_.y()) {
continue;
} else if (sampled_state.z() + robot_params_.center_offset.z() >
global_space_params_.max_val.z() - 0.5 * robot_box_size_.z()) {
continue;
}
// Check if surrounding area is free.
if (MapManager::VoxelStatus::kFree == map_manager_->getBoxStatus(
Eigen::Vector3d(sampled_state[0], sampled_state[1], sampled_state[2]) +
robot_params_.center_offset, robot_box_size_, true)) {
random_sampler.pushSample(sampled_state, true); // for debug purpose.
found = true;
} else {
stat_->num_vertices_fail++;
random_sampler.pushSample(sampled_state, false);
}
}
return found;
}
void Rrg::expandTreeStar(std::shared_ptr<GraphManager> graph_manager,
StateVec& new_state, ExpandGraphReport& rep) {
// Find nearest neighbour
Vertex* nearest_vertex = NULL;
if (!graph_manager->getNearestVertex(&new_state, &nearest_vertex)) {
rep.status = ExpandGraphStatus::kErrorKdTree;
return;
}
if (nearest_vertex == NULL) {
rep.status = ExpandGraphStatus::kErrorKdTree;
return;
}
// Check for collision of new connection plus some overshoot distance.
Eigen::Vector3d origin(nearest_vertex->state[0], nearest_vertex->state[1],
nearest_vertex->state[2]);
Eigen::Vector3d direction(new_state[0] - origin[0], new_state[1] - origin[1],
new_state[2] - origin[2]);
double direction_norm = direction.norm();
if (direction_norm > planning_params_.edge_length_max) {
direction = planning_params_.edge_length_max * direction.normalized();
} else if (direction_norm <= planning_params_.edge_length_min) {
// Should not add short edge.
rep.status = ExpandGraphStatus::kErrorShortEdge;
return;
}
// Recalculate the distance.
direction_norm = direction.norm();
new_state[0] = origin[0] + direction[0];
new_state[1] = origin[1] + direction[1];
new_state[2] = origin[2] + direction[2];
// Since we are buiding graph,
// Consider to check the overshoot for both 2 directions except root node.
Eigen::Vector3d overshoot_vec =
planning_params_.edge_overshoot * direction.normalized();
Eigen::Vector3d start_pos = origin + robot_params_.center_offset;
if (nearest_vertex->id != 0) start_pos = start_pos - overshoot_vec;
Eigen::Vector3d end_pos =
origin + robot_params_.center_offset + direction + overshoot_vec;
if (planning_params_.geofence_checking_enable &&
(GeofenceManager::CoordinateStatus::kViolated ==
geofence_manager_->getPathStatus(
Eigen::Vector2d(start_pos[0], start_pos[1]),
Eigen::Vector2d(end_pos[0], end_pos[1]),
Eigen::Vector2d(robot_box_size_[0], robot_box_size_[1])))) {
rep.status = ExpandGraphStatus::kErrorGeofenceViolated;
return;
}
bool connected_to_root = false;
if (MapManager::VoxelStatus::kFree ==
map_manager_->getPathStatus(start_pos, end_pos, robot_box_size_, true)) {
// Obstacle free.
// Re-wire the shortest one first.
std::vector<Vertex*> nearest_vertices;
if (!graph_manager->getNearestVertices(
&new_state, planning_params_.nearest_range, &nearest_vertices)) {
rep.status = ExpandGraphStatus::kErrorKdTree;
return;
}
// To save the computation from collision checking, we save feasible list
// from this first step.
std::vector<Vertex*> feasible_neigbors;
Vertex* v_min = nearest_vertex;
double c_min = v_min->distance + direction_norm;
origin << new_state[0], new_state[1], new_state[2];
for (int i = 0; i < nearest_vertices.size(); ++i) {
direction << nearest_vertices[i]->state[0] - new_state[0],
nearest_vertices[i]->state[1] - new_state[1],
nearest_vertices[i]->state[2] - new_state[2];
double d_norm = direction.norm();
if (d_norm == 0.0) continue;
Eigen::Vector3d p_start = origin + robot_params_.center_offset;
Eigen::Vector3d p_end = origin + robot_params_.center_offset + direction;
bool geofence_pass = true;
if (planning_params_.geofence_checking_enable &&
(GeofenceManager::CoordinateStatus::kViolated ==
geofence_manager_->getPathStatus(
Eigen::Vector2d(p_start[0], p_start[1]),
Eigen::Vector2d(p_end[0], p_end[1]),
Eigen::Vector2d(robot_box_size_[0], robot_box_size_[1])))) {
geofence_pass = false;
}
if (geofence_pass) {
if (MapManager::VoxelStatus::kFree ==
map_manager_->getPathStatus(p_start, p_end, robot_box_size_,
true)) {
feasible_neigbors.push_back(nearest_vertices[i]);
double cost_tmp = d_norm + nearest_vertices[i]->distance;
if (cost_tmp < c_min) {
v_min = nearest_vertices[i];
c_min = cost_tmp;
}
}
}
}
// Add the vertex with shortest distance to the tree (graph).
Vertex* new_vertex =
new Vertex(graph_manager->generateVertexID(), new_state);
new_vertex->parent = v_min;
new_vertex->distance = c_min;
v_min->children.push_back(new_vertex);
graph_manager->addVertex(new_vertex);
++rep.num_vertices_added;
rep.vertex_added = new_vertex;
graph_manager->addEdge(new_vertex, v_min, c_min - v_min->distance);
++rep.num_edges_added;
// Rewire neigbor nodes through newly added vertex if found shorter path.
origin << new_vertex->state[0], new_vertex->state[1], new_vertex->state[2];
for (auto& near_vertex : feasible_neigbors) {
direction << near_vertex->state[0] - new_vertex->state[0],
near_vertex->state[1] - new_vertex->state[1],
near_vertex->state[2] - new_vertex->state[2];
double d_norm = direction.norm();
if (d_norm == 0.0) continue;
double cost_tmp = d_norm + new_vertex->distance;
if (near_vertex->distance > cost_tmp) {
graph_manager->removeEdge(near_vertex, near_vertex->parent);
near_vertex->distance = cost_tmp;
near_vertex->parent = new_vertex;
graph_manager->addEdge(near_vertex, near_vertex->parent, d_norm);
}
}
} else {
stat_->num_edges_fail++;
if (stat_->num_edges_fail < 500) {
std::vector<double> vtmp = {start_pos[0], start_pos[1], start_pos[2],
end_pos[0], end_pos[1], end_pos[2]};
stat_->edges_fail.push_back(vtmp);
}
rep.status = ExpandGraphStatus::kErrorCollisionEdge;
return;
}
rep.status = ExpandGraphStatus::kSuccess;
}
void Rrg::expandGraph(std::shared_ptr<GraphManager> graph_manager,
StateVec& new_state, ExpandGraphReport& rep,
bool allow_short_edge) {
// Find nearest neighbour
Vertex* nearest_vertex = NULL;
if (!graph_manager->getNearestVertex(&new_state, &nearest_vertex)) {
rep.status = ExpandGraphStatus::kErrorKdTree;
return;
}
if (nearest_vertex == NULL) {
rep.status = ExpandGraphStatus::kErrorKdTree;
return;
}
// Check for collision of new connection plus some overshoot distance.
Eigen::Vector3d origin(nearest_vertex->state[0], nearest_vertex->state[1],
nearest_vertex->state[2]);
Eigen::Vector3d direction(new_state[0] - origin[0], new_state[1] - origin[1],
new_state[2] - origin[2]);
double direction_norm = direction.norm();
if (direction_norm > planning_params_.edge_length_max) {
direction = planning_params_.edge_length_max * direction.normalized();
} else if ((!allow_short_edge) &&
(direction_norm <= planning_params_.edge_length_min)) {
// Should not add short edge.
rep.status = ExpandGraphStatus::kErrorShortEdge;
return;
}
// Recalculate the distance.
direction_norm = direction.norm();
new_state[0] = origin[0] + direction[0];
new_state[1] = origin[1] + direction[1];
new_state[2] = origin[2] + direction[2];
// Since we are buiding graph,
// Consider to check the overshoot for both 2 directions except root node.
Eigen::Vector3d overshoot_vec =
planning_params_.edge_overshoot * direction.normalized();
Eigen::Vector3d start_pos = origin + robot_params_.center_offset;
if (nearest_vertex->id != 0) start_pos = start_pos - overshoot_vec;
Eigen::Vector3d end_pos =
origin + robot_params_.center_offset + direction + overshoot_vec;
if (planning_params_.geofence_checking_enable &&
(GeofenceManager::CoordinateStatus::kViolated ==
geofence_manager_->getPathStatus(
Eigen::Vector2d(start_pos[0], start_pos[1]),
Eigen::Vector2d(end_pos[0], end_pos[1]),
Eigen::Vector2d(robot_box_size_[0], robot_box_size_[1])))) {
rep.status = ExpandGraphStatus::kErrorGeofenceViolated;
return;
}
bool connected_to_root = false;
if (MapManager::VoxelStatus::kFree ==
map_manager_->getPathStatus(start_pos, end_pos, robot_box_size_, true)) {
Vertex* new_vertex =
new Vertex(graph_manager->generateVertexID(), new_state);
// Form a tree as the first step.
if (nearest_vertex->id == 0) connected_to_root = true;
new_vertex->parent = nearest_vertex;
new_vertex->distance = nearest_vertex->distance + direction_norm;
nearest_vertex->children.push_back(new_vertex);
graph_manager->addVertex(new_vertex);
++rep.num_vertices_added;
rep.vertex_added = new_vertex;
graph_manager->addEdge(new_vertex, nearest_vertex, direction_norm);
++rep.num_edges_added;
// Form more edges from neighbors if set RRG mode.
if (planning_params_.rr_mode == explorer::RRModeType::kGraph) {
std::vector<Vertex*> nearest_vertices;
if (!graph_manager->getNearestVertices(
&new_state, planning_params_.nearest_range, &nearest_vertices)) {
rep.status = ExpandGraphStatus::kErrorKdTree;
return;
}
origin << new_vertex->state[0],new_vertex->state[1],new_vertex->state[2];
for (int i = 0; i < nearest_vertices.size(); ++i) {
if (nearest_vertices[i]->id == 0) connected_to_root = true;
direction << nearest_vertices[i]->state[0] - origin[0],
nearest_vertices[i]->state[1] - origin[1],
nearest_vertices[i]->state[2] - origin[2];
double d_norm = direction.norm();
if ((d_norm > planning_params_.nearest_range_min) &&
(d_norm < planning_params_.nearest_range_max)) {
Eigen::Vector3d p_overshoot =
direction / d_norm * planning_params_.edge_overshoot;
Eigen::Vector3d p_start =
origin + robot_params_.center_offset - p_overshoot;
Eigen::Vector3d p_end =
origin + robot_params_.center_offset + direction;
if (nearest_vertices[i]->id != 0) p_end = p_end + p_overshoot;
bool geofence_pass = true;
if (planning_params_.geofence_checking_enable &&
(GeofenceManager::CoordinateStatus::kViolated ==
geofence_manager_->getPathStatus(
Eigen::Vector2d(p_start[0], p_start[1]),
Eigen::Vector2d(p_end[0], p_end[1]),
Eigen::Vector2d(robot_box_size_[0], robot_box_size_[1])))) {
geofence_pass = false;
}
if (geofence_pass) {
if (MapManager::VoxelStatus::kFree ==
map_manager_->getPathStatus(p_start, p_end, robot_box_size_,
true)) {
graph_manager->addEdge(new_vertex, nearest_vertices[i], d_norm);
++rep.num_edges_added;
}
}
}
}
}
} else {
stat_->num_edges_fail++;
if (stat_->num_edges_fail < 500) {
std::vector<double> vtmp = {start_pos[0], start_pos[1], start_pos[2],
end_pos[0], end_pos[1], end_pos[2]};
stat_->edges_fail.push_back(vtmp);
}
rep.status = ExpandGraphStatus::kErrorCollisionEdge;
return;
}
rep.status = ExpandGraphStatus::kSuccess;
}
void Rrg::expandGraphEdges(std::shared_ptr<GraphManager> graph_manager,
Vertex* new_vertex, ExpandGraphReport& rep) {
std::vector<Vertex*> nearest_vertices;
if (!graph_manager->getNearestVertices(&(new_vertex->state),
planning_params_.nearest_range,
&nearest_vertices)) {
rep.status = ExpandGraphStatus::kErrorKdTree;
return;
}
Eigen::Vector3d origin;
origin << new_vertex->state[0], new_vertex->state[1], new_vertex->state[2];
for (int i = 0; i < nearest_vertices.size(); ++i) {
Eigen::Vector3d direction;
direction << nearest_vertices[i]->state[0] - origin[0],
nearest_vertices[i]->state[1] - origin[1],
nearest_vertices[i]->state[2] - origin[2];
double d_norm = direction.norm();
if ((d_norm > planning_params_.edge_length_min) &&
(d_norm < planning_params_.edge_length_max)) {
Eigen::Vector3d p_overshoot =
direction / d_norm * planning_params_.edge_overshoot;
Eigen::Vector3d p_start =
origin + robot_params_.center_offset - p_overshoot;
Eigen::Vector3d p_end = origin + robot_params_.center_offset + direction;
if (nearest_vertices[i]->id != 0) p_end = p_end + p_overshoot;
if (MapManager::VoxelStatus::kFree ==
map_manager_->getPathStatus(p_start, p_end, robot_box_size_, true)) {
graph_manager->addEdge(new_vertex, nearest_vertices[i], d_norm);
++rep.num_edges_added;
}
}
}
rep.status = ExpandGraphStatus::kSuccess;
}
void Rrg::expandGraphEdgesBlindly(std::shared_ptr<GraphManager> graph_manager,
Vertex* new_vertex, double radius,
ExpandGraphReport& rep) {
std::vector<Vertex*> nearest_vertices;
if (!graph_manager->getNearestVertices(&(new_vertex->state), radius,
&nearest_vertices)) {
rep.status = ExpandGraphStatus::kNull;
return;
}
Eigen::Vector3d origin;
origin << new_vertex->state[0], new_vertex->state[1], new_vertex->state[2];
for (int i = 0; i < nearest_vertices.size(); ++i) {
Eigen::Vector3d direction;
direction << nearest_vertices[i]->state[0] - origin[0],
nearest_vertices[i]->state[1] - origin[1],
nearest_vertices[i]->state[2] - origin[2];
double d_norm = direction.norm();
graph_manager->addEdge(new_vertex, nearest_vertices[i], d_norm);
++rep.num_edges_added;
}
rep.status = ExpandGraphStatus::kSuccess;
}
Rrg::GraphStatus Rrg::buildGraph() {
START_TIMER(ttime);
int loop_count = 0;
int num_vertices = 1;
int num_edges = 0;
if (planning_params_.type == PlanningModeType::kVerticalExploration)
random_sampler_vertical_.reset();
else
random_sampler_.reset();
while ((loop_count++ < planning_params_.num_loops_max) &&
(num_vertices < planning_num_vertices_max_) &&
(num_edges < planning_num_edges_max_)) {
StateVec new_state;
if (planning_params_.type == PlanningModeType::kVerticalExploration) {
if (!sampleVertex(random_sampler_vertical_, root_vertex_->state,
new_state))
continue;
} else {
if (!sampleVertex(new_state)) continue;
}
ExpandGraphReport rep;
expandGraph(local_graph_, new_state, rep);
// expandTreeStar(local_graph_, new_state, rep);
if (rep.status == ExpandGraphStatus::kSuccess) {
num_vertices += rep.num_vertices_added;
num_edges += rep.num_edges_added;
}
if ((loop_count >= planning_params_.num_loops_cutoff) &&
(local_graph_->getNumVertices() <= 1)) {
break;
}
}
stat_->build_graph_time = GET_ELAPSED_TIME(ttime);
// Visualize geofence area.
if (planning_params_.geofence_checking_enable)
visualization_->visualizeGeofence(geofence_manager_);
planner_trigger_time_++;
ROS_INFO("Formed a graph with [%d] vertices and [%d] edges with [%d] loops",
num_vertices, num_edges, loop_count);
if (planning_params_.type == PlanningModeType::kVerticalExploration)
visualization_->visualizeSampler(random_sampler_vertical_);
else
visualization_->visualizeSampler(random_sampler_);
if (local_graph_->getNumVertices() > 1) {
visualization_->visualizeGraph(local_graph_);
return Rrg::GraphStatus::OK;
} else {
visualization_->visualizeFailedEdges(stat_);
ROS_INFO("Number of failed samples: [%d] vertices and [%d] edges",
stat_->num_vertices_fail, stat_->num_edges_fail);
return Rrg::GraphStatus::ERR_NO_FEASIBLE_PATH;
}
}
void Rrg::correctYaw() {
// Choose the heading angle tangent with the moving direction.
if (planning_params_.yaw_tangent_correction) {
int num_vertices = local_graph_->getNumVertices();
for (int id = 1; id < num_vertices; ++id) {
int pid = local_graph_->getParentIDFromShortestPath(id, local_graph_rep_);
Vertex* v = local_graph_->getVertex(id);
Vertex* vp = local_graph_->getVertex(pid);
Eigen::Vector3d vec(v->state[0] - vp->state[0],
v->state[1] - vp->state[1],
v->state[2] - vp->state[2]);
if (planning_params_.planning_backward) vec = -vec;
v->state[3] = std::atan2(vec[1], vec[0]);
}
}
}
Rrg::GraphStatus Rrg::evaluateGraph() {
START_TIMER(ttime);
Rrg::GraphStatus gstatus = Rrg::GraphStatus::OK;
// Dijkstra and mark leaf vertices.
local_graph_->findShortestPaths(local_graph_rep_);
local_graph_->findLeafVertices(local_graph_rep_);
std::vector<Vertex*> leaf_vertices;
local_graph_->getLeafVertices(leaf_vertices);
stat_->shortest_path_time = GET_ELAPSED_TIME(ttime);
// Yaw correction AFTER having shortest paths.
correctYaw();
// Gain calculation for each vertex.
computeExplorationGain();
// Gain evaluation for valid paths, starting from the leaf to the root.
START_TIMER(ttime);
double best_gain = 0;
int best_path_id = 0;
int num_leaf_vertices = leaf_vertices.size();
for (int i = 0; i < num_leaf_vertices; ++i) {
int id = leaf_vertices[i]->id;
std::vector<Vertex*> path;
local_graph_->getShortestPath(id, local_graph_rep_, true, path);
int path_size = path.size();
if (path_size > 1) {
// At least 2 vertices: root + leaf.
double path_gain = 0;
double lambda = planning_params_.path_length_penalty;
for (int ind = 0; ind < path_size; ++ind) {
path.pop_back();
Vertex* v_id = path[ind];
double path_length =
local_graph_->getShortestDistance(v_id->id, local_graph_rep_);
path_gain += v_id->vol_gain.gain * exp(-lambda * path_length);
v_id->vol_gain.accumulative_gain = path_gain;
}
// Compare with exploring direction to penalty not-forward paths.
if (planning_params_.type != PlanningModeType::kVerticalExploration) {
double lambda2 = planning_params_.path_direction_penalty;
std::vector<Eigen::Vector3d> path_list;
local_graph_->getShortestPath(id, local_graph_rep_, true, path_list);
double fw_ratio =
Trajectory::computeDistanceBetweenTrajectoryAndDirection(
path_list, exploring_direction_, 0.2, true);
path_gain *= exp(-lambda2 * fw_ratio);
}
if (path_gain > best_gain) {
best_gain = path_gain;
best_path_id = id;
}
}
}
// Visualization at the end.
visualization_->visualizeShortestPaths(local_graph_, local_graph_rep_);
if (best_gain > 0) {
visualization_->visualizeBestPaths(local_graph_, local_graph_rep_, 10,
best_path_id);
}
if (best_gain > 0) {
// create a branch
std::vector<int> path;
local_graph_->getShortestPath(best_path_id, local_graph_rep_, false, path);
for (int i = 0; i < (path.size() - 1); ++i) {
local_graph_->getVertex(path[i])->parent =
local_graph_->getVertex(path[i + 1]);
}
best_vertex_ = local_graph_->getVertex(path[0]);
//
ROS_INFO("Best path: with gain [%f] and ID [%d] ", best_gain, best_path_id);
gstatus = Rrg::GraphStatus::OK;
addFrontiers(best_path_id);
visualization_->visualizeGlobalGraph(global_graph_);
} else {
gstatus = Rrg::GraphStatus::NO_GAIN;
}
stat_->evaluate_graph_time = GET_ELAPSED_TIME(ttime);
stat_->printTime();
return gstatus;
}
bool Rrg::modifyPath(pcl::PointCloud<pcl::PointXYZ>* obstacle_pcl,
Eigen::Vector3d& p0, Eigen::Vector3d& p1,
Eigen::Vector3d& p1_mod) {
p1_mod = p1;
Eigen::Vector3d p_center;
p_center = (p0 + p1) / 2.0;
Eigen::Vector3d p_dir;
p_dir = (p1 - p0);
double radius = p_dir.norm() / 2.0;
Eigen::Vector3d x_axis(1.0, 0.0, 0.0);
Eigen::Quaternion<double> quat_W2S;
Eigen::Vector3d p_dir_norm = p_dir.normalized();
double yaw_angle = std::atan2(p_dir_norm.y(), p_dir_norm.x());
double pitch_angle = -std::atan2(p_dir_norm.z(),
std::sqrt(p_dir_norm.x() * p_dir_norm.x() +
p_dir_norm.y() * p_dir_norm.y()));
quat_W2S = Eigen::AngleAxisd(yaw_angle, Eigen::Vector3d::UnitZ()) *
Eigen::AngleAxisd(pitch_angle, Eigen::Vector3d::UnitY());
pcl::PointCloud<pcl::PointXYZ>* pcl_tf(new pcl::PointCloud<pcl::PointXYZ>());
Eigen::Translation<double, 3> trans_W2S(p_center);
Eigen::Transform<double, 3, Eigen::Affine> tf_W2S(trans_W2S * quat_W2S);
pcl::transformPointCloud(*obstacle_pcl, *pcl_tf, tf_W2S.inverse());
// Add a local bounding box
double kDx = robot_params_.safety_extension[0];
double kDy = robot_params_.safety_extension[1];
double kDz = robot_params_.safety_extension[2];
// 6 rectanges in form: ax+by+cz = 1
std::vector<Eigen::Vector3d> u_l;
std::vector<Eigen::Vector3d> p_l;
u_l.push_back(Eigen::Vector3d(1.0, 0.0, 0.0));
u_l.push_back(Eigen::Vector3d(1.0, 0.0, 0.0));
u_l.push_back(Eigen::Vector3d(0.0, 1.0, 0.0));
u_l.push_back(Eigen::Vector3d(0.0, 1.0, 0.0));
u_l.push_back(Eigen::Vector3d(0.0, 0.0, 1.0));
u_l.push_back(Eigen::Vector3d(0.0, 0.0, 1.0));
p_l.push_back(Eigen::Vector3d(-radius - kDx, 0.0, 0.0));
p_l.push_back(Eigen::Vector3d(radius + kDx, 0.0, 0.0));
p_l.push_back(Eigen::Vector3d(0.0, -kDy, 0.0));
p_l.push_back(Eigen::Vector3d(0.0, kDy, 0.0));
p_l.push_back(Eigen::Vector3d(0.0, 0.0, -kDz));
p_l.push_back(Eigen::Vector3d(0.0, 0.0, kDz));
std::vector<Eigen::Vector3d> hyperplane_list;
std::vector<Eigen::Vector3d> tangent_point_list;
for (int i = 0; i < 6; ++i) {
Eigen::Vector3d a_l;
a_l = u_l[i] / (u_l[i].dot(p_l[i]));
tangent_point_list.push_back(p_l[i]);
hyperplane_list.push_back(a_l);
}
// Keep points inside the local box only
pcl::PointCloud<pcl::PointXYZ>* pcl_in_box(
new pcl::PointCloud<pcl::PointXYZ>());
for (auto p = pcl_tf->begin(); p != pcl_tf->end(); ++p) {
// Check all 6 hyperplanes
const double kDSign = 0.05; // numeric issue
double sign;
int i = 0;
for (i = 0; i < 6; ++i) {
sign = p->x * hyperplane_list[i].x() + p->y * hyperplane_list[i].y() +
p->z * hyperplane_list[i].z() - 1;
if (sign > kDSign) break;
}
if (i == 6) {
// inside the local box
pcl_in_box->push_back(*p);
}
}
if (pcl_in_box->size())
pcl::copyPointCloud(*pcl_in_box, *pcl_tf);
else {
// full free space --> keep current vertex.
return true;
}
// Find closest point
double dist_min_sq = std::numeric_limits<double>::max();
Eigen::Vector3d p_tangent;
for (auto p = pcl_tf->begin(); p != pcl_tf->end(); ++p) {
double dist_t = p->x * p->x + p->y * p->y + p->z * p->z;
if (dist_t < dist_min_sq) {
dist_min_sq = dist_t;
p_tangent << p->x, p->y, p->z;
}
}
const double kDDist = 0.01; // deal with numeric error.
if ((dist_min_sq == std::numeric_limits<double>::max()) ||
(dist_min_sq < kDDist)) {
// the path is too close to obstacle.
return false;
}
double a = radius, b = radius, c = radius; // dimensions of the ellipsoid.
// Check if we need to adjust the sphere to ellipsoid.
if (dist_min_sq < (radius * radius)) {
// Reduce other axes
b = std::sqrt(
(p_tangent.y() * p_tangent.y() + p_tangent.z() * p_tangent.z()) /
(1 - p_tangent.x() * p_tangent.x() / (a * a)));
c = b; // Set equal b for now; but could increase.???
// Fit the first hyperplane: x x_l + y y_l + z z_l = 1
Eigen::Vector3d hyperplane_last =
Eigen::Vector3d(p_tangent.x() / (a * a), p_tangent.y() / (b * b),
p_tangent.z() / (c * c));
hyperplane_list.push_back(hyperplane_last);
tangent_point_list.push_back(p_tangent);
}
// Increase the ellipsoid and repeat.
bool stop = false;
int n_max = 0; // magic number: max 50 hyperplanes
while ((!stop) && (n_max < 50)) {
++n_max;
pcl::PointCloud<pcl::PointXYZ>* pcl_reduced(
new pcl::PointCloud<pcl::PointXYZ>());
// Also re-scale each dimension followed the dimentions of ellipsoid
if (hyperplane_list.size()) {
Eigen::Vector3d hyperplane_last;
hyperplane_last = hyperplane_list.back();
// Reduce point: keep points on the same side with zero origin (sign < 0)
for (auto p = pcl_tf->begin(); p != pcl_tf->end(); ++p) {
double sign = p->x * hyperplane_last.x() + p->y * hyperplane_last.y() +
p->z * hyperplane_last.z() - 1;
const double kDSign = -0.05; // numeric issue
if (sign < kDSign) {
// same side with the ellipsoid.
pcl_reduced->push_back(*p);
}
}
} else {
pcl::copyPointCloud(*pcl_tf, *pcl_reduced);
}
Eigen::Vector3d p_tangent1;
dist_min_sq = std::numeric_limits<double>::max();
for (auto p = pcl_reduced->begin(); p != pcl_reduced->end(); ++p) {
// Scale to get next closest point.
pcl::PointXYZ pv;
pv.x = p->x / a;
pv.y = p->y / b;
pv.z = p->z / c;
double dist_t = pv.x * pv.x + pv.y * pv.y + pv.z * pv.z;
if (dist_t < dist_min_sq) {
dist_min_sq = dist_t;
p_tangent1 << p->x, p->y, p->z;
}
}
if ((pcl_reduced->size() == 0) ||
(dist_min_sq == std::numeric_limits<double>::max())) {
stop = true;
} else {
double e_ext = dist_min_sq;
Eigen::Vector3d hyperplane_new = Eigen::Vector3d(
p_tangent1.x() / (a * a * e_ext), p_tangent1.y() / (b * b * e_ext),
p_tangent1.z() / (c * c * e_ext));
hyperplane_list.push_back(hyperplane_new);
tangent_point_list.push_back(p_tangent1);
pcl_tf->clear();
pcl::copyPointCloud(*pcl_reduced, *pcl_tf);
}
}
if (!stop) {
// Require too many hyperplanes
return false;
}
// Find the polygon formed from intersections between the bisector plane vs.
// all hyperplanes, Not sure how to get the closed-form solution, also issue
// with unknown voxels
// --> get average from uniform sampling on the y-z plane (body coordinate)
std::vector<Eigen::Vector3d> feasible_samples;
for (double dy = -kDy; dy < kDy; dy += 0.1) {
for (double dz = -kDz; dz < kDz; dz += 0.1) {
Eigen::Vector3d p(radius, dy, dz);
// check if this is inside all hyperplanes.
const double kDSign = -0.05; // numeric issue
double sign;
int i = 0;
for (i = 0; i < hyperplane_list.size(); ++i) {
sign = p.x() * hyperplane_list[i].x() + p.y() * hyperplane_list[i].y() +
p.z() * hyperplane_list[i].z() - 1;
if (sign > kDSign) break;
}
if (i == hyperplane_list.size()) {
feasible_samples.push_back(p);
}
}
}
for (int i = 0; i < hyperplane_list.size(); ++i) {
tangent_point_list[i] =
tf_W2S * tangent_point_list[i]; // convert back to world
Eigen::Matrix4d tf_inv_T = tf_W2S.matrix().inverse().transpose();
Eigen::Vector4d v_t;
v_t = tf_inv_T * Eigen::Vector4d(hyperplane_list[i].x(),
hyperplane_list[i].y(),
hyperplane_list[i].z(), -1.0);
v_t = v_t / (-v_t[3]);
hyperplane_list[i] << v_t.x(), v_t.y(), v_t.z();
}
p1_mod << 0.0, 0.0, 0.0;
int feasible_count = 0;
for (int i = 0; i < feasible_samples.size(); ++i) {
feasible_samples[i] =
tf_W2S * feasible_samples[i]; // convert back to world
// check if this is free voxel to deal with occluded area.
if (map_manager_->getVoxelStatus(feasible_samples[i]) ==
MapManager::VoxelStatus::kFree) {
feasible_corridor_pcl_->push_back(pcl::PointXYZ(feasible_samples[i].x(),
feasible_samples[i].y(),
feasible_samples[i].z()));
p1_mod = p1_mod + feasible_samples[i];
++feasible_count;
}
}
if (feasible_count) {
p1_mod = p1_mod / feasible_count;
} else {
return false;
}
visualization_->visualizeHyperplanes(p_center, hyperplane_list,
tangent_point_list);
return true;
}
void Rrg::addFrontiers(int best_vertex_id) {
// Add frontiers to the graph.
// 1) Check and mark if any vertex is potential frontier and leaf vertices.
// This should be done in buildGraph step, but for now, put everything here to
// test --> move to the expandGlobalGraph.
// 2) Re-update all previous frontiers in graph if they are still
// frontiers by checking if the are surrounded by normal vertices in local
// graph, change the status to normal.
// 3) Sort all the path with frontiers into desending list.
// 4) For each path, check if the frontier is surrounded by normal vertices
// or any frontiers. If yes, don't add this path;
// otherwise, add this path to the global graph.
ROS_INFO("Global graph: %d vertices, %d edges.",
global_graph_->getNumVertices(), global_graph_->getNumEdges());
bool update_global_frontiers = true;
if (update_global_frontiers) {
std::vector<Vertex*> global_frontiers;
int num_vertices = global_graph_->getNumVertices();
for (int id = 0; id < num_vertices; ++id) {
if (global_graph_->getVertex(id)->type == VertexType::kFrontier) {
global_frontiers.push_back(global_graph_->getVertex(id));
}
}
ROS_INFO("Have %d frontiers from global graph.",
(int)global_frontiers.size());
for (auto& v : global_frontiers) {
computeVolumetricGainRayModelNoBound(v->state, v->vol_gain);
if (!v->vol_gain.is_frontier) v->type = VertexType::kUnvisited;
}
}
// Get all potential frontiers at leaf vertices of newly sampled local graph.
std::vector<Vertex*> leaf_vertices;
local_graph_->getLeafVertices(leaf_vertices);
std::vector<Vertex*> frontier_vertices;
for (auto& v : leaf_vertices) {
if (v->type == VertexType::kFrontier) {
frontier_vertices.push_back(v);
}
}
ROS_INFO("Get %d leaf vertices from newly local graph.",
(int)leaf_vertices.size());
ROS_INFO("Get %d frontiers from newly local graph.",
(int)frontier_vertices.size());
// Clustering the frontier and add principle path to the global.
std::vector<int> cluster_ids = performShortestPathsClustering(
local_graph_, local_graph_rep_, frontier_vertices);
visualization_->visualizeClusteredPaths(local_graph_, local_graph_rep_,
frontier_vertices, cluster_ids);
const double kRangeCheck = 1.0;
const double kUpdateRadius = 3.0;
for (int i = 0; i < cluster_ids.size(); ++i) {
Vertex* nearest_vertex = NULL;
// To add principal path, verify if around that area already have vertices
// before. Also if the robot already passed that area before.
if (!global_graph_->getNearestVertexInRange(
&(local_graph_->getVertex(cluster_ids[i])->state), kRangeCheck,
&nearest_vertex)) {
StateVec* nearest_state = NULL;
if (!robot_state_hist_->getNearestStateInRange(
&(local_graph_->getVertex(cluster_ids[i])->state), kUpdateRadius,
&nearest_state)) {
std::vector<Vertex*> path;
local_graph_->getShortestPath(cluster_ids[i], local_graph_rep_, true,
path);
// Only keep frontier for the leaf vertex, the remaining should be
// cleared to normal.
for (auto pa = path.begin(); pa != (path.end() - 1); ++pa) {
(*pa)->type = VertexType::kUnvisited;
}
addRefPathToGraph(global_graph_, path);
}
}
}
visualization_->visualizeRobotStateHistory(robot_state_hist_->state_hist_);
}
void Rrg::freePointCloudtimerCallback(const ros::TimerEvent& event) {
if (!planning_params_.freespace_cloud_enable) return;
pcl::PointCloud<pcl::PointXYZ>::Ptr free_cloud_body(
new pcl::PointCloud<pcl::PointXYZ>);
std::vector<Eigen::Vector3d> multiray_endpoints_body;
for (auto sensor_name : free_frustum_params_.sensor_list) {
StateVec state;
state[0] = current_state_[0];
state[1] = current_state_[1];
state[2] = current_state_[2];
state[3] = current_state_[3];
// get frustum endpoints (They are in world frame)
free_frustum_params_.sensor[sensor_name].getFrustumEndpoints(
state, multiray_endpoints_body);
std::vector<Eigen::Vector3d> multiray_endpoints;
// Check it the full ray till max range is free(for voxblox only, for
// octomap just convert to world frame)
map_manager_->getFreeSpacePointCloud(multiray_endpoints_body, state,
free_cloud_body);
// convert the endpoint to sensor frame
pcl::PointCloud<pcl::PointXYZ>::Ptr free_cloud(
new pcl::PointCloud<pcl::PointXYZ>);
free_frustum_params_.sensor[sensor_name].convertBodyToSensor(
free_cloud_body, free_cloud);
sensor_msgs::PointCloud2 out_cloud;
pcl::toROSMsg(*free_cloud.get(), out_cloud);
out_cloud.header.frame_id =
free_frustum_params_.sensor[sensor_name].frame_id;
out_cloud.header.stamp = ros::Time::now();
free_cloud_pub_.publish(out_cloud);
}
}
void Rrg::expandGlobalGraphTimerCallback(const ros::TimerEvent& event) {
// Algorithm:
// Extract unvisited vertices in the global graph.
// Randomly choose a vertex then group all nearby vertices within a local
// bounding box. Repeat again until having set of local bounding box covered
// all unvisited vertices. Random sample a collision free vertex inside a
// local box, expand the graph, and compute the volumetric gain to check if
// this is frontier
ros::Time time_lim;
START_TIMER(time_lim);
// ROS_INFO("graphTimerCallback is triggered.");
if (planner_trigger_time_ == 0) return;
bool update_global_frontiers = false;
if (update_global_frontiers) {
std::vector<Vertex*> global_frontiers;
int num_vertices = global_graph_->getNumVertices();
for (int id = 0; id < num_vertices; ++id) {
if (global_graph_->getVertex(id)->type == VertexType::kFrontier) {
global_frontiers.push_back(global_graph_->getVertex(id));
}
}
for (auto& v : global_frontiers) {
// computeVolumetricGainRayModelNoBound(v->state, v->vol_gain);
computeVolumetricGainRayModel(v->state, v->vol_gain);
if (!v->vol_gain.is_frontier) v->type = VertexType::kUnvisited;
}
}
std::vector<Vertex*> unvisited_vertices;
int global_graph_size = global_graph_->getNumVertices();
for (int id = 0; id < global_graph_size; ++id) {
if (global_graph_->getVertex(id)->type == VertexType::kUnvisited) {
unvisited_vertices.push_back(global_graph_->getVertex(id));
}
}
if (unvisited_vertices.empty()) return;
int num_unvisited_vertices = unvisited_vertices.size();
const double kLocalBoxRadius = 10;
const double kLocalBoxRadiusSq = kLocalBoxRadius * kLocalBoxRadius;
std::vector<Eigen::Vector3d> cluster_centroids;
std::vector<Vertex*> unvisited_vertices_remain;
while (true) {
unvisited_vertices_remain.clear();
// Randomly pick a vertex
int ind = rand() % (unvisited_vertices.size());
// Find all vertices nearby this vertex.
// Compute the centroid of this cluster.
Eigen::Vector3d cluster_center(0, 0, 0);
int num_vertices_in_cluster = 0;
for (int i = 0; i < unvisited_vertices.size(); ++i) {
Eigen::Vector3d dist(
unvisited_vertices[i]->state.x() - unvisited_vertices[ind]->state.x(),
unvisited_vertices[i]->state.y() - unvisited_vertices[ind]->state.y(),
unvisited_vertices[i]->state.z() -
unvisited_vertices[ind]->state.z());
if (dist.squaredNorm() <= kLocalBoxRadiusSq) {
cluster_center =
cluster_center + Eigen::Vector3d(unvisited_vertices[i]->state.x(),
unvisited_vertices[i]->state.y(),
unvisited_vertices[i]->state.z());
++num_vertices_in_cluster;
} else {
unvisited_vertices_remain.push_back(unvisited_vertices[i]);
}
}
cluster_center = cluster_center / num_vertices_in_cluster;
cluster_centroids.push_back(cluster_center);
unvisited_vertices = unvisited_vertices_remain;
if (unvisited_vertices.empty()) break;
}
double time_elapsed = 0;
int loop_count = 0, loop_count_success = 0;
int num_vertices = 1;
int num_edges = 0;
while (time_elapsed < kGlobalGraphUpdateTimeBudget) {
time_elapsed = GET_ELAPSED_TIME(time_lim);
++loop_count;
for (int i = 0; i < cluster_centroids.size(); ++i) {
StateVec centroid_state(cluster_centroids[i].x(),
cluster_centroids[i].y(),
cluster_centroids[i].z(), 0);
StateVec new_state;
if (!sampleVertex(random_sampler_, centroid_state, new_state)) continue;
// Only expand samples in sparse areas & not yet passed by the robot & not
// closed to any frontiers
const double kSparseRadius = 2.0; // m
const double kOverlappedFrontierRadius = 3.0; // m
std::vector<StateVec*> s_res;
robot_state_hist_->getNearestStates(&new_state, kSparseRadius, &s_res);
if (s_res.size()) continue;
std::vector<Vertex*> v_res;
global_graph_->getNearestVertices(&new_state, kSparseRadius, &v_res);
if (v_res.size()) continue;
std::vector<Vertex*> f_res;
global_graph_->getNearestVertices(&new_state, kOverlappedFrontierRadius,
&f_res);
bool frontier_existed = false;
for (auto v : f_res) {
if (v->type == VertexType::kFrontier) {
frontier_existed = true;
break;
}
}
if (frontier_existed) continue;
loop_count_success++;
ExpandGraphReport rep;
expandGraph(global_graph_, new_state, rep);
if (rep.status == ExpandGraphStatus::kSuccess) {
computeVolumetricGainRayModel(rep.vertex_added->state,
rep.vertex_added->vol_gain, false);
if (rep.vertex_added->vol_gain.is_frontier)
rep.vertex_added->type = VertexType::kFrontier;
num_vertices += rep.num_vertices_added;
num_edges += rep.num_edges_added;
}
}
}
time_elapsed = GET_ELAPSED_TIME(time_lim);
}
void Rrg::printShortestPath(int id) {
std::vector<int> id_list;
local_graph_->getShortestPath(id, local_graph_rep_, false, id_list);
std::cout << "Path [id,acuumulative_gain] ["
<< local_graph_->getVertex(id)->id << ","
<< local_graph_->getVertex(id)->vol_gain.accumulative_gain << "] ";
int i = 0;
while (i < id_list.size()) {
std::cout << "<-- [" << local_graph_->getVertex(id_list[i])->id << "]";
++i;
}
std::cout << std::endl;
}
bool Rrg::search(geometry_msgs::Pose source_pose,
geometry_msgs::Pose target_pose, bool use_current_state,
std::vector<geometry_msgs::Pose>& path_ret) {
StateVec source;
if (use_current_state)
source = current_state_;
else
convertPoseMsgToState(source_pose, source);
StateVec target;
convertPoseMsgToState(target_pose, target);
std::shared_ptr<GraphManager> graph_search(new GraphManager());
RandomSamplingParams sampling_params;
ROS_WARN("Start searching ...");
int final_target_id;
ConnectStatus status = findPathToConnect(
source, target, graph_search, sampling_params, final_target_id, path_ret);
if (status == ConnectStatus::kSuccess)
return true;
else
return false;
// visualization
visualization_->visualizeGraph(graph_search);
visualization_->visualizeSampler(random_sampler_to_search_);
}
ConnectStatus Rrg::findPathToConnect(
StateVec& source, StateVec& target,
std::shared_ptr<GraphManager> graph_manager, RandomSamplingParams& params,
int& final_target_id, std::vector<geometry_msgs::Pose>& path_ret) {
ConnectStatus status;
path_ret.clear();
graph_manager->reset();
ROS_INFO("Search a path from src [%f,%f,%f] to tgt [%f,%f,%f]", source[0],
source[1], source[2], target[0], target[1], target[2]);
// Check a corner case if exists a direct collision-free path to connect
// source and target.
MapManager::VoxelStatus voxel_state;
bool try_straight_path = true;
if (try_straight_path) {
Eigen::Vector3d src_pos(source[0], source[1], source[2]);
Eigen::Vector3d tgt_pos(target[0], target[1], target[2]);
voxel_state = map_manager_->getPathStatus(
src_pos + robot_params_.center_offset,
tgt_pos + robot_params_.center_offset, robot_box_size_, true);
if (voxel_state == MapManager::VoxelStatus::kFree) {
ROS_INFO("Try straight path...");
// Add source to the graph.
Vertex* source_vertex =
new Vertex(graph_manager->generateVertexID(), source);
graph_manager->addVertex(source_vertex);
// Add target to the graph.
Vertex* target_vertex =
new Vertex(graph_manager->generateVertexID(), target);
graph_manager->addVertex(target_vertex);
graph_manager->addEdge(source_vertex, target_vertex,
(tgt_pos - src_pos).norm());
final_target_id = target_vertex->id;
geometry_msgs::Pose source_pose;
convertStateToPoseMsg(source, source_pose);
path_ret.push_back(source_pose);
geometry_msgs::Pose target_pose;
convertStateToPoseMsg(target, target_pose);
path_ret.push_back(target_pose);
// Modify heading angle.
Eigen::Vector3d vec(path_ret[1].position.x - path_ret[0].position.x,
path_ret[1].position.y - path_ret[0].position.y,
path_ret[1].position.z - path_ret[0].position.z);
double yaw = std::atan2(vec[1], vec[0]);
tf::Quaternion quat;
quat.setEuler(0.0, 0.0, yaw);
path_ret[1].orientation.x = quat.x();
path_ret[1].orientation.y = quat.y();
path_ret[1].orientation.z = quat.z();
path_ret[1].orientation.w = quat.w();
status = ConnectStatus::kSuccess;
return status;
}
}
// Verify source is collision free to go.
if (params.check_collision_at_source) {
voxel_state = map_manager_->getBoxStatus(
Eigen::Vector3d(source[0], source[1], source[2]) +
robot_params_.center_offset,
robot_box_size_, true);
if (MapManager::VoxelStatus::kFree != voxel_state) {
switch (voxel_state) {
case MapManager::VoxelStatus::kOccupied:
ROS_INFO("Source position contains Occupied voxels --> Stop.");
break;
case MapManager::VoxelStatus::kUnknown:
ROS_INFO("Source position contains Unknown voxels --> Stop.");
break;
}
status = ConnectStatus::kErrorCollisionAtSource;
return status;
}
}
// Add source to the graph.
Vertex* source_vertex = new Vertex(graph_manager->generateVertexID(), source);
graph_manager->addVertex(source_vertex);
// Start sampling points and add to the graph.
bool reached_target = false;
int num_paths_to_target = 0;
std::vector<Vertex*> target_neigbors;
int loop_count = 0;
int num_vertices = 0;
int num_edges = 0;
random_sampler_to_search_.reset();
bool stop_sampling = false;
while (!stop_sampling) {
StateVec new_state;
if (!sampleVertex(random_sampler_to_search_, source, new_state)) continue;
ExpandGraphReport rep;
expandGraph(graph_manager, new_state, rep);
if (rep.status == ExpandGraphStatus::kSuccess) {
num_vertices += rep.num_vertices_added;
num_edges += rep.num_edges_added;
// Check if this state reached the target.
Eigen::Vector3d radius_vec(new_state[0] - target[0],
new_state[1] - target[1],
new_state[2] - target[2]);
if (radius_vec.norm() < params.reached_target_radius) {
target_neigbors.push_back(rep.vertex_added);
reached_target = true;
++num_paths_to_target;
if (num_paths_to_target > params.num_paths_to_target_max)
stop_sampling = true;
}
}
if ((loop_count >= params.num_loops_cutoff) &&
(graph_manager->getNumVertices() <= 1)) {
stop_sampling = true;
}
if ((loop_count++ > params.num_loops_max) ||
(num_vertices > params.num_vertices_max) ||
(num_edges > params.num_edges_max))
stop_sampling = true;
}
ROS_INFO("Build a graph with %d vertices and %d edges.",
graph_manager->getNumVertices(), graph_manager->getNumEdges());
// Try to add target to graph as well.
bool added_target = false;
Vertex* target_vertex = NULL;
if (reached_target) {
ROS_WARN("Reached target.");
// Check if the target voxel is free, then try to add to the graph.
voxel_state = map_manager_->getBoxStatus(
Eigen::Vector3d(target[0], target[1], target[2]) +
robot_params_.center_offset,
robot_box_size_, true);
if (voxel_state == MapManager::VoxelStatus::kFree) {
ExpandGraphReport rep;
expandGraph(graph_manager, target, rep);
if (rep.status == ExpandGraphStatus::kSuccess) {
ROS_INFO("Added target to the graph successfully.");
num_vertices += rep.num_vertices_added;
num_edges += rep.num_edges_added;
added_target = true;
target_vertex = rep.vertex_added;
} else {
ROS_INFO("Cannot expand the graph to connect to the target.");
}
} else {
ROS_INFO("Target is not free, failed to add to the graph.");
}
} else {
ROS_WARN("ConnectStatus::kErrorNoFeasiblePath");
status = ConnectStatus::kErrorNoFeasiblePath;
return status;
}
// Get shortest path to the goal.
ShortestPathsReport graph_rep;
graph_manager->findShortestPaths(graph_rep);
// Get id list of the shortest path.
if (!added_target) {
ROS_INFO("Sorting best path.");
// Sort all the shortest path that go to target neigbors based on distance
// in ascending order.
std::sort(target_neigbors.begin(), target_neigbors.end(),
[&graph_manager, &graph_rep](const Vertex* a, const Vertex* b) {
return graph_manager->getShortestDistance(a->id, graph_rep) <
graph_manager->getShortestDistance(b->id, graph_rep);
});
// Pick the shortest one.
target_vertex = target_neigbors[0];
}
ROS_INFO("Get shortest path [%d] from %d path.", target_vertex->id,
(int)target_neigbors.size());
std::vector<int> path_id_list;
graph_manager->getShortestPath(target_vertex->id, graph_rep, false,
path_id_list);
final_target_id = target_vertex->id;
// Convert to the pose message path.
while (!path_id_list.empty()) {
geometry_msgs::Pose pose;
int id = path_id_list.back();
path_id_list.pop_back();
convertStateToPoseMsg(graph_manager->getVertex(id)->state, pose);
path_ret.push_back(pose);
}
// Set the heading angle tangent with the moving direction,
// from the second waypoint; the first waypoint keeps the same direction.
if (planning_params_.yaw_tangent_correction) {
for (int i = 0; i < (path_ret.size() - 1); ++i) {
Eigen::Vector3d vec(path_ret[i + 1].position.x - path_ret[i].position.x,
path_ret[i + 1].position.y - path_ret[i].position.y,
path_ret[i + 1].position.z - path_ret[i].position.z);
double yaw = std::atan2(vec[1], vec[0]);
tf::Quaternion quat;
quat.setEuler(0.0, 0.0, yaw);
path_ret[i + 1].orientation.x = quat.x();
path_ret[i + 1].orientation.y = quat.y();
path_ret[i + 1].orientation.z = quat.z();
path_ret[i + 1].orientation.w = quat.w();
}
}
ROS_WARN("Finish searching.");
status = ConnectStatus::kSuccess;
visualization_->visualizeBestPaths(graph_manager, graph_rep, 0,
final_target_id);
return status;
}
bool Rrg::loadParams() {
// Get the prefix name of the parameters.
std::string ns = ros::this_node::getName();
// Load all relevant parameters.
if (!sensor_params_.loadParams(ns + "/SensorParams")) return false;
if (!free_frustum_params_.loadParams(ns + "/FreeFrustumParams")) {
ROS_WARN("No setting for FreeFrustumParams.");
// return false;
}
if (!robot_params_.loadParams(ns + "/RobotParams")) return false;
if (!global_space_params_.loadParams(ns + "/BoundedSpaceParams/Global"))
return false;
if (!local_space_params_.loadParams(ns + "/BoundedSpaceParams/Local"))
return false;
if (!local_search_params_.loadParams(ns + "/BoundedSpaceParams/LocalSearch"))
return false;
if (!local_vertical_params_.loadParams(
ns + "/BoundedSpaceParams/LocalVerticalExp")) {
ROS_WARN("No setting for vertical exploration mode.");
// return false;
}
if (!planning_params_.loadParams(ns + "/PlanningParams")) return false;
// The sampler doesn't load params automatically.
// Remember to initialize the sampler in initializeParams() function.
if (!random_sampler_.loadParams(ns +
"/RandomSamplerParams/SamplerForExploration"))
return false;
if (!random_sampler_to_search_.loadParams(
ns + "/RandomSamplerParams/SamplerForSearching"))
return false;
if (!random_sampler_vertical_.loadParams(
ns + "/RandomSamplerParams/SamplerForVerticalExp")) {
ROS_WARN("No setting for vertical exploration mode.");
// return false;
}
if (!robot_dynamics_params_.loadParams(ns + "/RobotDynamics")) return false;
if (!geofence_manager_->loadParams(ns + "/GeofenceParams")) return false;
// @todo A temporary solution to load the velocity setting.
planning_params_.v_max = robot_dynamics_params_.v_max;
planning_params_.v_homing_max = robot_dynamics_params_.v_homing_max;
// All other relevant const values should be initialized in this call
// after loading parameters for all fields.
initializeParams();
return true;
}
void Rrg::initializeParams() {
// Compute constant values after loading all parameters to speed up
// Set sampler params from BoundedSpaceParams if required.
random_sampler_.setParams(global_space_params_, local_space_params_);
random_sampler_to_search_.setParams(global_space_params_,
local_search_params_);
if (random_sampler_vertical_.isReady)
random_sampler_vertical_.setParams(global_space_params_,
local_vertical_params_);
// Precompute the robot box for planning.
robot_params_.getPlanningSize(robot_box_size_);
planning_num_vertices_max_ = planning_params_.num_vertices_max;
planning_num_edges_max_ = planning_params_.num_edges_max;
// Get the global bounding box in the setting as default.
// Visualize in the beginning for checking.
global_bound_.setDefault(global_space_params_.min_val,
global_space_params_.max_val);
visualization_->visualizeWorkspace(current_state_, global_space_params_,
local_space_params_);
}
bool Rrg::setGlobalBound(planner_msgs::PlanningBound& bound,
bool reset_to_default) {
if (!reset_to_default) {
// Make sure current position of the robot and its bounding box is inside
// the global bound.
if ((current_state_.x() + robot_params_.center_offset.x() <
bound.min_val.x + 0.5 * robot_box_size_.x()) ||
(current_state_.y() + robot_params_.center_offset.y() <
bound.min_val.y + 0.5 * robot_box_size_.y()) ||
(current_state_.z() + robot_params_.center_offset.z() <
bound.min_val.z + 0.5 * robot_box_size_.z()) ||
(current_state_.x() + robot_params_.center_offset.x() >
bound.max_val.x - 0.5 * robot_box_size_.x()) ||
(current_state_.y() + robot_params_.center_offset.y() >
bound.max_val.y - 0.5 * robot_box_size_.y()) ||
(current_state_.z() + robot_params_.center_offset.z() >
bound.max_val.z - 0.5 * robot_box_size_.z())) {
ROS_WARN(
"[GlobalBound] Failed to change since robot's position is outside "
"the global bound.");
return false;
}
Eigen::Vector3d v_min, v_max;
global_bound_.get(v_min, v_max);
v_min.x() = bound.min_val.x;
v_min.y() = bound.min_val.y;
if (bound.use_z_val) v_min.z() = bound.min_val.z;
v_max.x() = bound.max_val.x;
v_max.y() = bound.max_val.y;
if (!bound.use_z_val) v_max.z() = bound.max_val.z;
global_bound_.set(v_min, v_max);
global_space_params_.min_val = v_min;
global_space_params_.max_val = v_max;
ROS_WARN(
"[GlobalBound] Changed successfully: Min [%f, %f, %f], Max [%f, %f, "
"%f]",
v_min.x(), v_min.y(), v_min.z(), v_max.x(), v_max.y(), v_max.z());
} else {
// reset to an original bounding box.
global_bound_.reset();
Eigen::Vector3d v_min, v_max;
global_bound_.get(v_min, v_max);
global_space_params_.min_val = v_min;
global_space_params_.max_val = v_max;
ROS_WARN(
"[GlobalBound] Reset to default: Min [%f, %f, %f], Max [%f, %f, %f]",
v_min.x(), v_min.y(), v_min.z(), v_max.x(), v_max.y(), v_max.z());
}
visualization_->visualizeWorkspace(current_state_, global_space_params_,
local_space_params_);
return true;
}
void Rrg::getGlobalBound(planner_msgs::PlanningBound& bound) {
global_bound_.get(bound.min_val, bound.max_val);
}
void Rrg::computeExplorationGain(bool only_leaf_vertices) {
const int id_viz = 20; // random vertex to show volumetric gain.
ros::Time tim;
START_TIMER(tim);
// Compute gain of all vertices in one function.
for (const auto& v : local_graph_->vertices_map_) {
bool viz_en = false;
if (v.second->id == id_viz) viz_en = true;
if (planning_params_.use_ray_model_for_volumetric_gain) {
if ((!only_leaf_vertices) || (v.second->is_leaf_vertex))
computeVolumetricGainRayModel(v.second->state, v.second->vol_gain,
viz_en);
} else {
if ((!only_leaf_vertices) || (v.second->is_leaf_vertex))
computeVolumetricGain(v.second->state, v.second->vol_gain, viz_en);
}
if (v.second->vol_gain.is_frontier) v.second->type = VertexType::kFrontier;
}
stat_->compute_exp_gain_time = GET_ELAPSED_TIME(tim);
}
void Rrg::computeVolumetricGain(StateVec& state, VolumetricGain& vgain,
bool vis_en) {
vgain.reset();
double step_size = planning_params_.exp_gain_voxel_size;
// Scan winthin a local space and sensor range.
// Compute the local bound.
Eigen::Vector3d bound_min;
Eigen::Vector3d bound_max;
if (local_space_params_.type == BoundedSpaceType::kSphere) {
for (int i = 0; i < 3; ++i) {
bound_min[i] = root_vertex_->state[i] - local_space_params_.radius -
local_space_params_.radius_extension;
bound_max[i] = root_vertex_->state[i] + local_space_params_.radius +
local_space_params_.radius_extension;
}
} else if (local_space_params_.type == BoundedSpaceType::kCuboid) {
for (int i = 0; i < 3; ++i) {
bound_min[i] = root_vertex_->state[i] + local_space_params_.min_val[i] +
local_space_params_.min_extension[i];
bound_max[i] = root_vertex_->state[i] + local_space_params_.max_val[i] +
local_space_params_.max_extension[i];
}
} else {
PLANNER_ERROR("Local space is not defined.");
return;
}
// Refine the bound with global bound.
if (global_space_params_.type == BoundedSpaceType::kSphere) {
for (int i = 0; i < 3; i++) {
bound_min[i] =
std::max(bound_min[i], -global_space_params_.radius -
global_space_params_.radius_extension);
bound_max[i] =
std::min(bound_max[i], global_space_params_.radius +
global_space_params_.radius_extension);
}
} else if (global_space_params_.type == BoundedSpaceType::kCuboid) {
for (int i = 0; i < 3; i++) {
bound_min[i] =
std::max(bound_min[i], global_space_params_.min_val[i] +
global_space_params_.min_extension[i]);
bound_max[i] =
std::min(bound_max[i], global_space_params_.max_val[i] +
global_space_params_.max_extension[i]);
}
} else {
PLANNER_ERROR("Global space is not defined.");
return;
}
std::vector<std::tuple<int, int, int>> gain_log;
gain_log.clear();
std::vector<std::pair<Eigen::Vector3d, MapManager::VoxelStatus>> voxel_log;
voxel_log.clear();
// Compute for each sensor in the exploration sensor list.
// However, this would be a problem if those sensors have significant overlap.
for (int ind = 0; ind < planning_params_.exp_sensor_list.size(); ++ind) {
std::string sensor_name = planning_params_.exp_sensor_list[ind];
// Refine the bound within an effective range.
for (int i = 0; i < 3; i++) {
bound_min[i] =
std::max(bound_min[i],
state[i] - sensor_params_.sensor[sensor_name].max_range);
bound_max[i] =
std::min(bound_max[i],
state[i] + sensor_params_.sensor[sensor_name].max_range);
}
int num_unknown_voxels = 0, num_free_voxels = 0, num_occupied_voxels = 0;
// Check all voxels inside local bound.
Eigen::Vector3d origin(state[0], state[1], state[2]);
Eigen::Vector3d voxel;
for (voxel[0] = bound_min[0]; voxel[0] < bound_max[0];
voxel[0] += step_size) {
for (voxel[1] = bound_min[1]; voxel[1] < bound_max[1];
voxel[1] += step_size) {
for (voxel[2] = bound_min[2]; voxel[2] < bound_max[2];
voxel[2] += step_size) {
if (sensor_params_.sensor[sensor_name].isInsideFOV(state, voxel)) {
MapManager::VoxelStatus vs_ray =
map_manager_->getRayStatus(origin, voxel, true);
if (vs_ray != MapManager::VoxelStatus::kOccupied) {
MapManager::VoxelStatus vs = map_manager_->getVoxelStatus(voxel);
if (vs == MapManager::VoxelStatus::kUnknown) {
++num_unknown_voxels;
} else if (vs == MapManager::VoxelStatus::kFree) {
++num_free_voxels;
} else if (vs == MapManager::VoxelStatus::kOccupied) {
++num_occupied_voxels;
}
if (vis_en) voxel_log.push_back(std::make_pair(voxel, vs));
}
}
}
}
}
gain_log.push_back(std::make_tuple(num_unknown_voxels, num_free_voxels,
num_occupied_voxels));
}
// Return gain values.
for (int i = 0; i < gain_log.size(); ++i) {
int num_unknown_voxels = std::get<0>(gain_log[i]);
int num_free_voxels = std::get<1>(gain_log[i]);
int num_occupied_voxels = std::get<2>(gain_log[i]);
vgain.num_unknown_voxels += num_unknown_voxels;
vgain.num_free_voxels += num_free_voxels;
vgain.num_occupied_voxels += num_occupied_voxels;
vgain.gain += num_unknown_voxels * planning_params_.unknown_voxel_gain +
num_free_voxels * planning_params_.free_voxel_gain +
num_occupied_voxels * planning_params_.occupied_voxel_gain;
}
// Visualize if required.
if (vis_en) {
visualization_->visualizeVolumetricGain(bound_min, bound_max, voxel_log,
step_size);
}
}
void Rrg::computeVolumetricGainRayModel(StateVec& state, VolumetricGain& vgain,
bool vis_en) {
vgain.reset();
// Scan winthin a local space and sensor range.
// Compute the local bound.
Eigen::Vector3d bound_min;
Eigen::Vector3d bound_max;
if (local_space_params_.type == BoundedSpaceType::kSphere) {
for (int i = 0; i < 3; ++i) {
bound_min[i] = root_vertex_->state[i] - local_space_params_.radius -
local_space_params_.radius_extension;
bound_max[i] = root_vertex_->state[i] + local_space_params_.radius +
local_space_params_.radius_extension;
}
} else if (local_space_params_.type == BoundedSpaceType::kCuboid) {
for (int i = 0; i < 3; ++i) {
bound_min[i] = root_vertex_->state[i] + local_space_params_.min_val[i] +
local_space_params_.min_extension[i];
bound_max[i] = root_vertex_->state[i] + local_space_params_.max_val[i] +
local_space_params_.max_extension[i];
}
} else {
PLANNER_ERROR("Local space is not defined.");
return;
}
// Refine the bound with global bound.
if (global_space_params_.type == BoundedSpaceType::kSphere) {
for (int i = 0; i < 3; i++) {
bound_min[i] =
std::max(bound_min[i], -global_space_params_.radius -
global_space_params_.radius_extension);
bound_max[i] =
std::min(bound_max[i], global_space_params_.radius +
global_space_params_.radius_extension);
}
} else if (global_space_params_.type == BoundedSpaceType::kCuboid) {
for (int i = 0; i < 3; i++) {
bound_min[i] =
std::max(bound_min[i], global_space_params_.min_val[i] +
global_space_params_.min_extension[i]);
bound_max[i] =
std::min(bound_max[i], global_space_params_.max_val[i] +
global_space_params_.max_extension[i]);
}
} else {
PLANNER_ERROR("Global space is not defined.");
return;
}
std::vector<std::tuple<int, int, int>> gain_log;
std::vector<std::pair<Eigen::Vector3d, MapManager::VoxelStatus>> voxel_log;
int raw_unk_voxels_count = 0;
// Compute for each sensor in the exploration sensor list.
// However, this would be a problem if those sensors have significant overlap.
for (int ind = 0; ind < planning_params_.exp_sensor_list.size(); ++ind) {
std::string sensor_name = planning_params_.exp_sensor_list[ind];
// Refine the bound within an effective range.
for (int i = 0; i < 3; i++) {
bound_min[i] =
std::max(bound_min[i],
state[i] - sensor_params_.sensor[sensor_name].max_range);
bound_max[i] =
std::min(bound_max[i],
state[i] + sensor_params_.sensor[sensor_name].max_range);
}
Eigen::Vector3d origin(state[0], state[1], state[2]);
std::tuple<int, int, int> gain_log_tmp;
std::vector<std::pair<Eigen::Vector3d, MapManager::VoxelStatus>>
voxel_log_tmp;
std::vector<Eigen::Vector3d> multiray_endpoints;
sensor_params_.sensor[sensor_name].getFrustumEndpoints(state,
multiray_endpoints);
map_manager_->getScanStatus(origin, multiray_endpoints, gain_log_tmp,
voxel_log_tmp);
int num_unknown_voxels = 0, num_free_voxels = 0, num_occupied_voxels = 0;
// Have to remove those not belong to the local bound.
// At the same time check if this is frontier.
for (auto& vl : voxel_log_tmp) {
Eigen::Vector3d voxel = vl.first;
MapManager::VoxelStatus vs = vl.second;
if (vs == MapManager::VoxelStatus::kUnknown) ++raw_unk_voxels_count;
int j = 0;
for (j = 0; j < 3; j++) {
if ((voxel[j] < bound_min[j]) || (voxel[j] > bound_max[j])) break;
}
if (j == 3) {
// valid voxel.
if (vs == MapManager::VoxelStatus::kUnknown) {
++num_unknown_voxels;
} else if (vs == MapManager::VoxelStatus::kFree) {
++num_free_voxels;
} else if (vs == MapManager::VoxelStatus::kOccupied) {
++num_occupied_voxels;
} else {
ROS_ERROR("Unsupported voxel type.");
}
if (vis_en) voxel_log.push_back(std::make_pair(voxel, vs));
}
}
gain_log.push_back(std::make_tuple(num_unknown_voxels, num_free_voxels,
num_occupied_voxels));
if (vis_en) {
visualization_->visualizeRays(state, multiray_endpoints);
}
// Check if it is a potential frontier.
if (sensor_params_.sensor[sensor_name].isFrontier(
num_unknown_voxels * map_manager_->getResolution())) {
vgain.is_frontier = true; // Event E2
}
}
// Return gain values.
for (int i = 0; i < gain_log.size(); ++i) {
int num_unknown_voxels = std::get<0>(gain_log[i]);
int num_free_voxels = std::get<1>(gain_log[i]);
int num_occupied_voxels = std::get<2>(gain_log[i]);
vgain.num_unknown_voxels += num_unknown_voxels;
vgain.num_free_voxels += num_free_voxels;
vgain.num_occupied_voxels += num_occupied_voxels;
vgain.gain += num_unknown_voxels * planning_params_.unknown_voxel_gain +
num_free_voxels * planning_params_.free_voxel_gain +
num_occupied_voxels * planning_params_.occupied_voxel_gain;
}
// Visualize if required.
if (vis_en) {
visualization_->visualizeVolumetricGain(bound_min, bound_max, voxel_log,
map_manager_->getResolution());
}
}
void Rrg::computeVolumetricGainRayModelNoBound(StateVec& state,
VolumetricGain& vgain) {
vgain.reset();
// Scan winthin a GLOBAL space and sensor range.
Eigen::Vector3d bound_min;
Eigen::Vector3d bound_max;
if (global_space_params_.type == BoundedSpaceType::kSphere) {
for (int i = 0; i < 3; i++) {
bound_min[i] =
-global_space_params_.radius - global_space_params_.radius_extension;
bound_max[i] =
global_space_params_.radius + global_space_params_.radius_extension;
}
} else if (global_space_params_.type == BoundedSpaceType::kCuboid) {
for (int i = 0; i < 3; i++) {
bound_min[i] = global_space_params_.min_val[i] +
global_space_params_.min_extension[i];
bound_max[i] = global_space_params_.max_val[i] +
global_space_params_.max_extension[i];
}
} else {
PLANNER_ERROR("Global space is not defined.");
return;
}
std::vector<std::tuple<int, int, int>> gain_log;
std::vector<std::pair<Eigen::Vector3d, MapManager::VoxelStatus>> voxel_log;
// @TODO tung.
// Compute for each sensor in the exploration sensor list.
// However, this would be a problem if those sensors have significant overlap.
for (int ind = 0; ind < planning_params_.exp_sensor_list.size(); ++ind) {
std::string sensor_name = planning_params_.exp_sensor_list[ind];
// Refine the bound within an effective range.
for (int i = 0; i < 3; i++) {
bound_min[i] =
std::max(bound_min[i],
state[i] - sensor_params_.sensor[sensor_name].max_range);
bound_max[i] =
std::min(bound_max[i],
state[i] + sensor_params_.sensor[sensor_name].max_range);
}
Eigen::Vector3d origin(state[0], state[1], state[2]);
std::tuple<int, int, int> gain_log_tmp;
std::vector<std::pair<Eigen::Vector3d, MapManager::VoxelStatus>>
voxel_log_tmp;
std::vector<Eigen::Vector3d> multiray_endpoints;
sensor_params_.sensor[sensor_name].getFrustumEndpoints(state,
multiray_endpoints);
map_manager_->getScanStatus(origin, multiray_endpoints, gain_log_tmp,
voxel_log_tmp);
int num_unknown_voxels = 0, num_free_voxels = 0, num_occupied_voxels = 0;
// Have to remove those not belong to the local bound.
// At the same time check if this is frontier.
for (auto& vl : voxel_log_tmp) {
Eigen::Vector3d voxel = vl.first;
MapManager::VoxelStatus vs = vl.second;
int j = 0;
for (j = 0; j < 3; j++) {
if ((voxel[j] < bound_min[j]) || (voxel[j] > bound_max[j])) break;
}
if (j == 3) {
// valid voxel.
if (vs == MapManager::VoxelStatus::kUnknown) {
++num_unknown_voxels;
} else if (vs == MapManager::VoxelStatus::kFree) {
++num_free_voxels;
} else if (vs == MapManager::VoxelStatus::kOccupied) {
++num_occupied_voxels;
} else {
ROS_ERROR("Unsupported voxel type.");
}
}
}
gain_log.push_back(std::make_tuple(num_unknown_voxels, num_free_voxels,
num_occupied_voxels));
// Check if it is a potential frontier.
if (sensor_params_.sensor[sensor_name].isFrontier(
num_unknown_voxels * map_manager_->getResolution())) {
vgain.is_frontier = true; // Event E2
}
}
// Return gain values.
for (int i = 0; i < gain_log.size(); ++i) {
int num_unknown_voxels = std::get<0>(gain_log[i]);
int num_free_voxels = std::get<1>(gain_log[i]);
int num_occupied_voxels = std::get<2>(gain_log[i]);
vgain.num_unknown_voxels += num_unknown_voxels;
vgain.num_free_voxels += num_free_voxels;
vgain.num_occupied_voxels += num_occupied_voxels;
vgain.gain += num_unknown_voxels * planning_params_.unknown_voxel_gain +
num_free_voxels * planning_params_.free_voxel_gain +
num_occupied_voxels * planning_params_.occupied_voxel_gain;
}
}
void Rrg::setRootStateForPlanning(const geometry_msgs::Pose& root_pose) {
// If require plan ahead --> use the end pose from the last best path.
// Otherwise, use current pose.
state_for_planning_[0] = root_pose.position.x;
state_for_planning_[1] = root_pose.position.y;
state_for_planning_[2] = root_pose.position.z;
state_for_planning_[3] = tf::getYaw(root_pose.orientation);
if ((state_for_planning_[0] == 0.0) && (state_for_planning_[1] == 0.0) &&
(state_for_planning_[2] == 0)) {
planning_params_.use_current_state = true;
} else {
planning_params_.use_current_state = false;
}
}
bool Rrg::setHomingPos() {
if (global_graph_->getNumVertices() == 0) {
ROS_INFO("Global graph is empty: add current state as homing position.");
Vertex* g_root_vertex =
new Vertex(global_graph_->generateVertexID(), current_state_);
global_graph_->addVertex(g_root_vertex);
return true;
} else {
ROS_INFO("Global graph is not empty, can not set current state as homing.");
return false;
}
}
std::vector<geometry_msgs::Pose> Rrg::searchHomingPath(
std::string tgt_frame, const StateVec& current_state) {
std::vector<geometry_msgs::Pose> ret_path;
ret_path.clear();
if (global_graph_->getNumVertices() <= 1) {
ROS_WARN("[GlobalGraph] Graph is empty, nothing to search for homing.");
return ret_path;
}
StateVec cur_state;
cur_state << current_state[0], current_state[1], current_state[2],
current_state[3];
Vertex* nearest_vertex = NULL;
if (!global_graph_->getNearestVertex(&cur_state, &nearest_vertex))
return ret_path;
if (nearest_vertex == NULL) return ret_path;
Eigen::Vector3d origin(nearest_vertex->state[0], nearest_vertex->state[1],
nearest_vertex->state[2]);
Eigen::Vector3d direction(cur_state[0] - origin[0], cur_state[1] - origin[1],
cur_state[2] - origin[2]);
double direction_norm = direction.norm();
Vertex* link_vertex = NULL;
const double kRadiusLimit = 1.0;
const double kRadiusDelta = 0.2;
bool connect_state_to_graph = true;
if (direction_norm <= kRadiusLimit) {
// Note: if kRadiusLimit <= edge_length_min it will fail with
// kErrorShortEdge, dirty fix to check max
// @TODO: find better way to do this.
// Blindly add a link/vertex to the graph if small radius.
Vertex* new_vertex =
new Vertex(global_graph_->generateVertexID(), cur_state);
new_vertex->parent = nearest_vertex;
new_vertex->distance = nearest_vertex->distance + direction_norm;
nearest_vertex->children.push_back(new_vertex);
global_graph_->addVertex(new_vertex);
global_graph_->addEdge(new_vertex, nearest_vertex, direction_norm);
// Add edges only from this vertex.
ExpandGraphReport rep;
expandGraphEdges(global_graph_, new_vertex, rep);
link_vertex = new_vertex;
} else {
ROS_WARN("[GlobalGraph] Try to add current state to the graph.");
ExpandGraphReport rep;
expandGraph(global_graph_, cur_state, rep);
if (rep.status == ExpandGraphStatus::kSuccess) {
ROS_WARN("[GlobalGraph] Added successfully.");
link_vertex = rep.vertex_added;
} else {
// Not implemented solution for this case yet.
// Hopefully this one will not happen if the global planner always adds
// vertices from odometry --> naive backtracking.
connect_state_to_graph = false;
ROS_WARN("[GlobalGraph] Can not add current state to graph since: ");
switch (rep.status) {
case ExpandGraphStatus::kErrorKdTree:
ROS_WARN("kErrorKdTree.");
break;
case ExpandGraphStatus::kErrorCollisionEdge:
ROS_WARN("kErrorCollisionEdge.");
break;
case ExpandGraphStatus::kErrorShortEdge:
ROS_WARN("kErrorShortEdge.");
break;
}
ROS_WARN("[GlobalGraph] Failed to find global path.");
}
}
if (connect_state_to_graph) {
if (!global_graph_->findShortestPaths(global_graph_rep_)) {
ROS_ERROR("[GlobalGraph] Failed to find shortest path.");
return ret_path;
}
std::vector<int> homing_path_id;
global_graph_->getShortestPath(link_vertex->id, global_graph_rep_, false,
homing_path_id);
if (homing_path_id.empty() || homing_path_id.back() != 0) {
ROS_ERROR("[GlobalGraph] Could not find a path to home.");
return ret_path;
}
int homing_path_id_size = homing_path_id.size();
for (int i = 0; i < homing_path_id_size; ++i) {
StateVec state = global_graph_->getVertex(homing_path_id[i])->state;
tf::Quaternion quat;
quat.setEuler(0.0, 0.0, state[3]);
tf::Vector3 origin(state[0], state[1], state[2]);
tf::Pose poseTF(quat, origin);
geometry_msgs::Pose pose;
tf::poseTFToMsg(poseTF, pose);
ret_path.push_back(pose);
}
// Set the heading angle tangent with the moving direction,
// from the second waypoint; the first waypoint keeps the same direction.
if (planning_params_.yaw_tangent_correction) {
bool is_similar = comparePathWithDirectionApprioximately(
ret_path, tf::getYaw(ret_path[0].orientation));
for (int i = 0; i < (ret_path.size() - 1); ++i) {
Eigen::Vector3d vec;
if ((!planning_params_.homing_backward) || (is_similar)) {
vec << ret_path[i + 1].position.x - ret_path[i].position.x,
ret_path[i + 1].position.y - ret_path[i].position.y,
ret_path[i + 1].position.z - ret_path[i].position.z;
} else if (planning_params_.homing_backward) {
vec << ret_path[i].position.x - ret_path[i + 1].position.x,
ret_path[i].position.y - ret_path[i + 1].position.y,
ret_path[i].position.z - ret_path[i + 1].position.z;
}
double yaw = std::atan2(vec[1], vec[0]);
tf::Quaternion quat;
quat.setEuler(0.0, 0.0, yaw);
ret_path[i + 1].orientation.x = quat.x();
ret_path[i + 1].orientation.y = quat.y();
ret_path[i + 1].orientation.z = quat.z();
ret_path[i + 1].orientation.w = quat.w();
}
}
visualization_->visualizeHomingPaths(global_graph_, global_graph_rep_,
link_vertex->id);
}
visualization_->visualizeGlobalGraph(global_graph_);
return ret_path;
}
std::vector<geometry_msgs::Pose> Rrg::getHomingPath(std::string tgt_frame) {
// ros::Duration(3.0).sleep(); // sleep to unblock the thread to get and
// update all latest pose update.
//ros::spinOnce();
std::vector<geometry_msgs::Pose> ret_path;
ret_path = searchHomingPath(tgt_frame, current_state_);
if (ret_path.size() < 1) return ret_path;
// Re-assign yaw in beginning (HNI)
double yaw = current_state_[3];
tf::Quaternion quat;
quat.setEuler(0.0, 0.0, yaw);
ret_path[0].orientation.x = quat.x();
ret_path[0].orientation.y = quat.y();
ret_path[0].orientation.z = quat.z();
ret_path[0].orientation.w = quat.w();
const bool clean_short_edges = true;
if (clean_short_edges && (robot_params_.type == RobotType::kLeggedRobot)) {
// check if the path is weird: sudden change in the orientation
// find segments that need to be improved build the graph
// to reconnect those segments only, keep the remaining the same
std::vector<geometry_msgs::Pose> mod_path;
if (reconnectPathBlindly(ret_path, mod_path)) {
ret_path = mod_path;
}
}
// Modify the best path.
if (planning_params_.path_safety_enhance_enable) {
ros::Time mod_time;
START_TIMER(mod_time);
std::vector<geometry_msgs::Pose> mod_path;
if (improveFreePath(ret_path, mod_path)) {
ret_path = mod_path;
// Re-assign yaw angle after modification.
if (planning_params_.yaw_tangent_correction) {
bool is_similar = comparePathWithDirectionApprioximately(
ret_path, tf::getYaw(ret_path[0].orientation));
for (int i = 0; i < (ret_path.size() - 1); ++i) {
Eigen::Vector3d vec;
if ((!planning_params_.homing_backward) || (is_similar)) {
vec << ret_path[i + 1].position.x - ret_path[i].position.x,
ret_path[i + 1].position.y - ret_path[i].position.y,
ret_path[i + 1].position.z - ret_path[i].position.z;
} else if (planning_params_.homing_backward) {
vec << ret_path[i].position.x - ret_path[i + 1].position.x,
ret_path[i].position.y - ret_path[i + 1].position.y,
ret_path[i].position.z - ret_path[i + 1].position.z;
}
double yaw = std::atan2(vec[1], vec[0]);
tf::Quaternion quat;
quat.setEuler(0.0, 0.0, yaw);
ret_path[i + 1].orientation.x = quat.x();
ret_path[i + 1].orientation.y = quat.y();
ret_path[i + 1].orientation.z = quat.z();
ret_path[i + 1].orientation.w = quat.w();
}
}
}
double dmod_time = GET_ELAPSED_TIME(mod_time);
ROS_WARN("Compute an aternate path for homing in %f(s)", dmod_time);
visualization_->visualizeModPath(mod_path);
}
visualization_->visualizeRefPath(ret_path);
return ret_path;
}
bool Rrg::reconnectPathBlindly(std::vector<geometry_msgs::Pose>& ref_path,
std::vector<geometry_msgs::Pose>& mod_path) {
// Divide and conquer/Coarse to fine
// Interpolate the path into intermidiate nodes and reconnect using graph
if (ref_path.size() <= 2) return false;
// Interpolate the whole path to the finer resolution.
const double kPathResolution = 0.2;
Trajectory::PathType path_extract;
Trajectory::extractPathFromTrajectory(ref_path, path_extract);
Trajectory::PathType path_intp;
if (!Trajectory::interpolatePath(path_extract, kPathResolution, path_intp))
return false;
std::shared_ptr<GraphManager> path_graph;
path_graph.reset(new GraphManager());
StateVec root_state(path_intp[0][0], path_intp[0][1], path_intp[0][2], 0);
Vertex* root_vertex = new Vertex(path_graph->generateVertexID(), root_state);
path_graph->addVertex(root_vertex);
// Add all remaining vertices of the path.
std::vector<Vertex*> vertex_list;
vertex_list.push_back(root_vertex);
Vertex* parent_vertex = root_vertex;
for (int i = 1; i < path_intp.size(); ++i) {
StateVec new_state(path_intp[i][0], path_intp[i][1], path_intp[i][2], 0);
Vertex* new_vertex = new Vertex(path_graph->generateVertexID(), new_state);
new_vertex->parent = parent_vertex;
Eigen::Vector3d dist(new_state[0] - parent_vertex->state[0],
new_state[1] - parent_vertex->state[1],
new_state[2] - parent_vertex->state[2]);
new_vertex->distance = parent_vertex->distance + dist.norm();
parent_vertex->children.push_back(new_vertex);
path_graph->addVertex(new_vertex);
path_graph->addEdge(new_vertex, parent_vertex, dist.norm());
vertex_list.push_back(new_vertex);
parent_vertex = new_vertex;
}
// Build edges around vertices if possible to get better path.
const double kBlindConnectionRadius = 0.1;
int n_vertices = 0;
int n_edges = 0;
// Assume the path is verified collision free.
for (int i = 0; i < vertex_list.size(); ++i) {
ExpandGraphReport rep;
expandGraphEdgesBlindly(path_graph, vertex_list[i], kBlindConnectionRadius,
rep);
if (rep.status == ExpandGraphStatus::kSuccess) {
n_vertices += rep.num_vertices_added;
n_edges += rep.num_edges_added;
}
}
// Find the shortest path again
ShortestPathsReport path_graph_rep;
path_graph_rep.reset();
path_graph->findShortestPaths(path_graph_rep);
std::vector<Eigen::Vector3d> shortest_path;
path_graph->getShortestPath(path_graph->getNumVertices() - 1, path_graph_rep,
true, shortest_path);
// Keep the first orientation, the remaining could be adjusted.
mod_path.clear();
mod_path.push_back(ref_path[0]);
double prev_yaw = tf::getYaw(mod_path[0].orientation);
Eigen::Vector3d new_node;
for (int i = 0; i < shortest_path.size() - 1; ++i) {
double new_yaw = std::atan2(shortest_path[i + 1][1] - shortest_path[i][1],
shortest_path[i + 1][0] - shortest_path[i][0]);
double yaw_diff = new_yaw - prev_yaw;
truncateYaw(yaw_diff);
const double kYawEpsilon = 0.01;
if (std::abs(yaw_diff) > kYawEpsilon) {
if (i) {
// already added [0] element.
StateVec st(shortest_path[i][0], shortest_path[i][1],
shortest_path[i][2], prev_yaw);
geometry_msgs::Pose pose_tmp;
convertStateToPoseMsg(st, pose_tmp);
mod_path.push_back(pose_tmp);
}
prev_yaw = new_yaw;
}
}
// Add the last pose.
mod_path.push_back(ref_path.back());
return true;
}
std::vector<geometry_msgs::Pose> Rrg::getBestPath(std::string tgt_frame,
int& status) {
// Decide if need to go home.
if (planning_params_.auto_homing_enable) {
status = planner_msgs::planner_srv::Response::kHoming;
const double kTimeDelta = 20;
std::vector<geometry_msgs::Pose> homing_path;
double time_elapsed = 0.0;
if ((ros::Time::now()).toSec() != 0.0) {
if (rostime_start_.toSec() == 0.0) rostime_start_ = ros::Time::now();
time_elapsed = (double)((ros::Time::now() - rostime_start_).toSec());
}
double time_budget_remaining =
planning_params_.time_budget_limit - time_elapsed;
if (time_budget_remaining <= 0.0) {
ROS_WARN("RAN OUT OF TIME BUDGET --> STOP HERE.");
return homing_path;
}
if (current_battery_time_remaining_ <= 0.0) {
ROS_WARN("RAN OUT OF BATTERY --> STOP HERE.");
return homing_path;
}
// Check two conditions whatever which one comes first.
double time_remaining =
std::min(time_budget_remaining, current_battery_time_remaining_);
// homing_path = getHomingPath(tgt_frame);
// Start searching from current root vertex of spanning local graph.
Vertex* root_vertex = local_graph_->getVertex(0);
homing_path = searchHomingPath(tgt_frame, root_vertex->state);
if (!homing_path.empty()) {
double homing_len = Trajectory::getPathLength(homing_path);
double time_to_home = homing_len / planning_params_.v_homing_max;
ROS_INFO("Time to home: %f; Time remaining: %f", time_to_home,
time_remaining);
const double kTimeDelta = 20;
if (std::abs(time_to_home - time_remaining) < kTimeDelta) {
ROS_WARN("REACHED TIME LIMIT: HOMING ENGAGED.");
return homing_path;
}
} else {
// @TODO Issue with global graph, cannot find a homing path.
ROS_WARN("Can not find a path to return home from here.");
}
}
std::vector<geometry_msgs::Pose> ret;
int id = best_vertex_->id;
if (id == 0) return ret;
// Get potentially exploring direction.
std::vector<Eigen::Vector3d> best_path_3d;
local_graph_->getShortestPath(id, local_graph_rep_, true, best_path_3d);
double best_path_direction =
Trajectory::estimateDirectionFromPath(best_path_3d);
constexpr double kDiffAngleForwardThres = 0.5 * (M_PI + M_PI / 3);
bool res = compareAngles(exploring_direction_, best_path_direction,
kDiffAngleForwardThres);
if (planning_params_.type != PlanningModeType::kVerticalExploration) {
if (!res) {
ROS_WARN("Changing exploration direction.[%f --> %f]",
exploring_direction_, best_path_direction);
status = planner_msgs::planner_srv::Response::kBackward;
} else {
ROS_INFO("Current exploring direction: %f; New path direction: %f",
exploring_direction_, best_path_direction);
status = planner_msgs::planner_srv::Response::kForward;
}
}
// Extract path.
double traverse_length = 0;
double traverse_time = 0;
std::vector<StateVec> best_path;
local_graph_->getShortestPath(id, local_graph_rep_, true, best_path);
Eigen::Vector3d p0(best_path[0][0], best_path[0][1], best_path[0][2]);
std::vector<Vertex*> best_path_vertices;
local_graph_->getShortestPath(best_vertex_->id, local_graph_rep_, true,
best_path_vertices);
const double kLenMin = 1.0;
const double kLenMinMin = 0.3;
std::vector<Eigen::Vector3d> path_vec;
local_graph_->getShortestPath(best_vertex_->id, local_graph_rep_, true,
path_vec);
double total_len = Trajectory::getPathLength(path_vec);
double len_min_thres = kLenMin;
if (planning_params_.type != PlanningModeType::kVerticalExploration) {
len_min_thres = kLenMinMin;
}
if (total_len <= len_min_thres) {
ROS_WARN("Best path is too short.");
return ret;
}
std::vector<Vertex*> ref_vertices;
for (int i = 0; i < best_path.size(); ++i) {
Eigen::Vector3d p1(best_path[i][0], best_path[i][1], best_path[i][2]);
Eigen::Vector3d dir_vec = p1 - p0;
// ERROR: Re-confirm this is a safe path.
Eigen::Vector3d p_overshoot =
dir_vec.normalized() * planning_params_.edge_overshoot;
Eigen::Vector3d p_start = p0 + robot_params_.center_offset - p_overshoot;
Eigen::Vector3d p_end =
p0 + robot_params_.center_offset + dir_vec + p_overshoot;
if ((dir_vec.norm() > 0) &&
(MapManager::VoxelStatus::kFree !=
map_manager_->getPathStatus(p_start, p_end, robot_box_size_, true))) {
ROS_INFO("Segment [%d] is not clear.", i);
}
tf::Quaternion quat;
quat.setEuler(0.0, 0.0, best_path[i][3]);
tf::Vector3 origin(best_path[i][0], best_path[i][1], best_path[i][2]);
tf::Pose poseTF(quat, origin);
geometry_msgs::Pose pose;
tf::poseTFToMsg(poseTF, pose);
ret.push_back(pose);
// Prepare for homing feature.
ref_vertices.push_back(best_path_vertices[i]);
double seg_length = (p1 - p0).norm();
traverse_length += seg_length;
traverse_time += seg_length / planning_params_.v_max;
if ((traverse_length > planning_params_.traverse_length_max) ||
(traverse_time > planning_params_.traverse_time_max)) {
break;
}
p0 = p1;
}
ROS_INFO("Best path: size = %d, length = %f, time = %f", (int)ret.size(),
traverse_length, traverse_time);
// Put this into global graph for homing later.
bool path_added = false;
// Modify the best path.
if (planning_params_.path_safety_enhance_enable) {
ros::Time mod_time;
START_TIMER(mod_time);
std::vector<geometry_msgs::Pose> mod_path;
if (improveFreePath(ret, mod_path)) {
ret = mod_path;
addRefPathToGraph(global_graph_, mod_path);
path_added = true;
}
double dmod_time = GET_ELAPSED_TIME(mod_time);
ROS_WARN("Compute an aternate path in %f(s)", dmod_time);
visualization_->visualizeModPath(mod_path);
}
if (!path_added) {
addRefPathToGraph(global_graph_, ref_vertices);
}
visualization_->visualizeRefPath(ret);
return ret;
}
bool Rrg::improveFreePath(const std::vector<geometry_msgs::Pose>& path_orig,
std::vector<geometry_msgs::Pose>& path_mod) {
// Few heuristics to improve the path.
// a) Shorten path by reducing intermidiate nodes. (be careful with turning
// cases) Shorten/reduce some very short paths to prevent small motion and
// sudden change in angles.
// b) Adjust nodes to its neighbors to improve safety
// c) Ignore leaf node of the path to prevent the robot to come too close the
// obstacle
if (path_orig.empty()) return false;
// Feature a) Remove short intermidiate vertices.
std::vector<geometry_msgs::Pose> path_mod1 = path_orig;
const double kSegmentLenMin = 0.5;
bool cont_refine = true;
while (cont_refine) {
cont_refine = false;
for (int i = 0; i < (path_mod1.size() - 2); ++i) {
Eigen::Vector3d p_start(path_mod1[i].position.x, path_mod1[i].position.y,
path_mod1[i].position.z);
Eigen::Vector3d p_int(path_mod1[i + 1].position.x,
path_mod1[i + 1].position.y,
path_mod1[i + 1].position.z);
Eigen::Vector3d p_end(path_mod1[i + 2].position.x,
path_mod1[i + 2].position.y,
path_mod1[i + 2].position.z);
Eigen::Vector3d segment = p_int - p_start;
double segment_len = segment.norm();
// ROS_WARN("Segment length %f.", segment_len);
if (segment_len < kSegmentLenMin) {
if ((MapManager::VoxelStatus::kFree ==
map_manager_->getPathStatus(p_start, p_end, robot_box_size_,
true)) &&
(!planning_params_.geofence_checking_enable ||
(GeofenceManager::CoordinateStatus::kOK ==
geofence_manager_->getPathStatus(
Eigen::Vector2d(p_start[0], p_start[1]),
Eigen::Vector2d(p_end[0], p_end[1]),
Eigen::Vector2d(robot_box_size_[0], robot_box_size_[1]))))) {
// ignore the intermidiate nore, combine the first to the last node.
ROS_WARN("Combine nodes to remove short segments.");
path_mod1.erase(path_mod1.begin() + i + 1);
cont_refine = true;
break;
}
}
}
}
// Implement (b) first: form a safe corridor along each path from cutting
// hyperplanes.
feasible_corridor_pcl_.reset(new pcl::PointCloud<pcl::PointXYZ>());
geometry_msgs::Pose pose0;
pose0.position.x = path_mod1[0].position.x;
pose0.position.y = path_mod1[0].position.y;
pose0.position.z = path_mod1[0].position.z;
pose0.orientation.x = path_mod1[0].orientation.x;
pose0.orientation.y = path_mod1[0].orientation.y;
pose0.orientation.z = path_mod1[0].orientation.z;
pose0.orientation.w = path_mod1[0].orientation.w;
path_mod.push_back(pose0);
bool mod_success = true;
for (int i = 1; i < path_mod1.size(); ++i) {
Eigen::Vector3d p0(path_mod1[i - 1].position.x, path_mod1[i - 1].position.y,
path_mod1[i - 1].position.z);
Eigen::Vector3d p0_mod(path_mod[i - 1].position.x,
path_mod[i - 1].position.y,
path_mod[i - 1].position.z);
Eigen::Vector3d p1(path_mod1[i].position.x, path_mod1[i].position.y,
path_mod1[i].position.z);
Eigen::Vector3d p1_parallel = p0_mod + p1 - p0;
Eigen::Vector3d p2;
bool do_check_p2 = false;
if (i < path_mod1.size() - 1) {
do_check_p2 = true;
p2 = Eigen::Vector3d(path_mod1[i + 1].position.x,
path_mod1[i + 1].position.y,
path_mod1[i + 1].position.z);
}
Eigen::Vector3d p1_target;
bool seg_free = true;
if (MapManager::VoxelStatus::kFree ==
map_manager_->getPathStatus(p0_mod, p1_parallel, robot_box_size_,
true)) {
p1_target = p1_parallel;
} else if (MapManager::VoxelStatus::kFree ==
map_manager_->getPathStatus(p0_mod, p1, robot_box_size_, true)) {
p1_target = p1;
} else {
seg_free = false;
}
Eigen::Vector3d p1_mod;
geometry_msgs::Pose pose;
Eigen::Vector3d p_center;
p_center = (p0_mod + p1_target) / 2.0;
Eigen::Vector3d p_dir;
p_dir = (p1 - p0);
double radius = p_dir.norm() / 2.0;
// add a local bounding box
Eigen::Vector3d local_bbx(2 * (radius + robot_params_.safety_extension[0]),
2 * robot_params_.safety_extension[1],
2 * robot_params_.safety_extension[2]);
std::vector<Eigen::Vector3d> occupied_voxels;
std::vector<Eigen::Vector3d> free_voxels;
map_manager_->extractLocalMapAlongAxis(p_center, p_dir, local_bbx,
occupied_voxels, free_voxels);
pcl::PointCloud<pcl::PointXYZ>* obstacle_pcl(
new pcl::PointCloud<pcl::PointXYZ>());
for (auto& v : occupied_voxels) {
obstacle_pcl->push_back(pcl::PointXYZ(v.x(), v.y(), v.z()));
}
if (seg_free && (modifyPath(obstacle_pcl, p0_mod, p1_target, p1_mod))) {
// Verify collision-free again with the map & geofence.
if ((MapManager::VoxelStatus::kFree !=
map_manager_->getPathStatus(p0_mod, p1_mod, robot_box_size_,
true)) ||
(planning_params_.geofence_checking_enable &&
(GeofenceManager::CoordinateStatus::kViolated ==
geofence_manager_->getPathStatus(
Eigen::Vector2d(p0_mod[0], p0_mod[1]),
Eigen::Vector2d(p1_mod[0], p1_mod[1]),
Eigen::Vector2d(robot_box_size_[0], robot_box_size_[1])))) ||
(do_check_p2 &&
((MapManager::VoxelStatus::kFree !=
map_manager_->getPathStatus(p1_mod, p2, robot_box_size_, true)) ||
(planning_params_.geofence_checking_enable &&
(GeofenceManager::CoordinateStatus::kViolated ==
geofence_manager_->getPathStatus(
Eigen::Vector2d(p1_mod[0], p1_mod[1]),
Eigen::Vector2d(p2[0], p2[1]),
Eigen::Vector2d(robot_box_size_[0],
robot_box_size_[1]))))))) {
p1_mod = p1;
mod_success = false;
ROS_WARN("Newly modified path is not collision-free.");
break; // break to save time @recheck
}
} else {
p1_mod = p1;
// mod_success = false;
// break; // break to save time @recheck
}
pose.position.x = p1_mod.x();
pose.position.y = p1_mod.y();
pose.position.z = p1_mod.z();
path_mod.push_back(pose);
}
// Correct the heading angle tangent with the moving direction again.
// Re-Assign the first heading
path_mod[0].orientation.x = path_orig[0].orientation.x;
path_mod[0].orientation.y = path_orig[0].orientation.y;
path_mod[0].orientation.z = path_orig[0].orientation.z;
path_mod[0].orientation.w = path_orig[0].orientation.w;
if ((mod_success) && (planning_params_.yaw_tangent_correction)) {
for (int i = 1; i < path_mod.size(); ++i) {
Eigen::Vector3d vec(path_mod[i].position.x - path_mod[i - 1].position.x,
path_mod[i].position.y - path_mod[i - 1].position.y,
path_mod[i].position.z - path_mod[i - 1].position.z);
if (planning_params_.planning_backward) vec = -vec;
double yawhalf = 0.5 * std::atan2(vec[1], vec[0]);
path_mod[i].orientation.x = 0.0;
path_mod[i].orientation.y = 0.0;
path_mod[i].orientation.z = sin(yawhalf);
path_mod[i].orientation.w = cos(yawhalf);
}
}
visualization_->visualizePCL(feasible_corridor_pcl_.get());
return mod_success;
}
bool Rrg::addRefPathToGraph(const std::shared_ptr<GraphManager> graph_manager,
const std::vector<Vertex*>& vertices) {
if (vertices.size() <= 0) return false;
// The whole path is collision free already and start from root vertex.
// We only need to link the first vertex to the existing graph.
// Then add the whole path to the graph.
// Finally, add more edges along the path to the graph.
StateVec first_state;
first_state << vertices[0]->state[0], vertices[0]->state[1],
vertices[0]->state[2], vertices[0]->state[3];
Vertex* nearest_vertex = NULL;
if (!graph_manager->getNearestVertex(&first_state, &nearest_vertex))
return false;
if (nearest_vertex == NULL) return false;
Eigen::Vector3d origin(nearest_vertex->state[0], nearest_vertex->state[1],
nearest_vertex->state[2]);
Eigen::Vector3d direction(first_state[0] - origin[0],
first_state[1] - origin[1],
first_state[2] - origin[2]);
double direction_norm = direction.norm();
Vertex* parent_vertex = NULL;
const double kDeltaLimit = 0.1;
const double kRadiusLimit = 0.5;
// Add root vertex first.
if (direction_norm <= kDeltaLimit) {
parent_vertex = nearest_vertex;
} else if (direction_norm <=
std::max(kRadiusLimit, planning_params_.edge_length_min)) {
// @TODO: find better way to do this.
// Blindly add a link/vertex to the graph.
Vertex* new_vertex =
new Vertex(graph_manager->generateVertexID(), first_state);
new_vertex->parent = nearest_vertex;
new_vertex->distance = nearest_vertex->distance + direction_norm;
nearest_vertex->children.push_back(new_vertex);
graph_manager->addVertex(new_vertex);
graph_manager->addEdge(new_vertex, nearest_vertex, direction_norm);
parent_vertex = new_vertex;
} else {
ROS_WARN("[GlobalGraph] Try to add current state to the graph.");
ExpandGraphReport rep;
expandGraph(graph_manager, first_state, rep);
if (rep.status == ExpandGraphStatus::kSuccess) {
ROS_WARN("[GlobalGraph] Added successfully.");
parent_vertex = rep.vertex_added;
} else {
ROS_WARN("[GlobalGraph] Can not add current state to the global graph.");
return false;
}
}
// Add all remaining vertices of the path.
std::vector<Vertex*> vertex_list;
vertex_list.push_back(parent_vertex);
for (int i = 1; i < vertices.size(); ++i) {
StateVec new_state;
new_state << vertices[i]->state[0], vertices[i]->state[1],
vertices[i]->state[2], vertices[i]->state[3];
Eigen::Vector3d origin(parent_vertex->state[0], parent_vertex->state[1],
parent_vertex->state[2]);
Eigen::Vector3d direction(new_state[0] - origin[0],
new_state[1] - origin[1],
new_state[2] - origin[2]);
double direction_norm = direction.norm();
Vertex* new_vertex =
new Vertex(graph_manager->generateVertexID(), new_state);
new_vertex->type = vertices[i]->type;
new_vertex->parent = parent_vertex;
new_vertex->distance = parent_vertex->distance + direction_norm;
parent_vertex->children.push_back(new_vertex);
graph_manager->addVertex(new_vertex);
graph_manager->addEdge(new_vertex, parent_vertex, direction_norm);
vertex_list.push_back(new_vertex);
parent_vertex = new_vertex;
}
// Build edges around vertices if possible to get better path.
int n_vertices = 0;
int n_edges = 0;
// Assume the path is verified collision free.
for (int i = 0; i < vertex_list.size(); ++i) {
int num_vertices_added = 0;
int num_edges_added = 0;
ExpandGraphReport rep;
expandGraphEdges(graph_manager, vertex_list[i], rep);
if (rep.status == ExpandGraphStatus::kSuccess) {
n_vertices += num_vertices_added;
n_edges += num_edges_added;
} else {
switch (rep.status) {
case ExpandGraphStatus::kErrorKdTree:
ROS_WARN("Can not add this vertex: kErrorKdTree.");
break;
case ExpandGraphStatus::kErrorCollisionEdge:
ROS_WARN("Can not add this vertex: kErrorCollisionEdge.");
break;
case ExpandGraphStatus::kErrorShortEdge:
ROS_WARN("Can not add this vertex: kErrorShortEdge.");
break;
}
}
}
const bool path_intp_add = true;
const double intp_len = 1.0; // m
if (path_intp_add) {
// Add some intermidiate vertices along the path to densify the global
// graph.
for (int i = 0; i < (vertex_list.size() - 1); ++i) {
Eigen::Vector3d start_vertex(vertex_list[i]->state.x(),
vertex_list[i]->state.y(),
vertex_list[i]->state.z());
Eigen::Vector3d end_vertex(vertex_list[i + 1]->state.x(),
vertex_list[i + 1]->state.y(),
vertex_list[i + 1]->state.z());
Eigen::Vector3d edge_vec = end_vertex - start_vertex;
double edge_length = edge_vec.norm();
if (edge_length <= intp_len) continue;
edge_vec.normalize();
int n_intp = (int)std::ceil(edge_length / intp_len); // segments
Vertex* prev_vertex = vertex_list[i];
double acc_len = 0;
for (int j = 1; j < n_intp; ++j) {
Eigen::Vector3d new_v;
new_v = start_vertex + j * intp_len * edge_vec;
StateVec new_state;
new_state << new_v[0], new_v[1], new_v[2], vertex_list[i]->state[3];
Vertex* new_vertex =
new Vertex(graph_manager->generateVertexID(), new_state);
graph_manager->addVertex(new_vertex);
graph_manager->addEdge(new_vertex, prev_vertex, intp_len);
prev_vertex = new_vertex;
acc_len += intp_len;
}
// Link the last connection
double last_edge_len = edge_length - acc_len;
graph_manager->addEdge(prev_vertex, vertex_list[i + 1], last_edge_len);
}
}
return true;
}
bool Rrg::addRefPathToGraph(const std::shared_ptr<GraphManager> graph_manager,
const std::vector<geometry_msgs::Pose>& path) {
if (path.size() <= 0) return false;
// The whole path is collision free already and start from root vertex.
// We only need to link the first vertex to the existing graph.
// Then add the whole path to the graph.
// Finally, add more edges along the path to the graph.
StateVec first_state;
first_state << path[0].position.x, path[0].position.y, path[0].position.z,
0.0;
Vertex* nearest_vertex = NULL;
if (!graph_manager->getNearestVertex(&first_state, &nearest_vertex))
return false;
if (nearest_vertex == NULL) return false;
Eigen::Vector3d origin(nearest_vertex->state[0], nearest_vertex->state[1],
nearest_vertex->state[2]);
Eigen::Vector3d direction(first_state[0] - origin[0],
first_state[1] - origin[1],
first_state[2] - origin[2]);
double direction_norm = direction.norm();
Vertex* parent_vertex = NULL;
const double kDeltaLimit = 0.1;
const double kRadiusLimit = 0.5;
// Add root vertex first.
if (direction_norm <= kDeltaLimit) {
parent_vertex = nearest_vertex;
} else if (direction_norm <=
std::max(kRadiusLimit, planning_params_.edge_length_min)) {
// @TODO: find better way to do this.
// Blindly add a link/vertex to the graph.
Vertex* new_vertex =
new Vertex(graph_manager->generateVertexID(), first_state);
new_vertex->parent = nearest_vertex;
new_vertex->distance = nearest_vertex->distance + direction_norm;
nearest_vertex->children.push_back(new_vertex);
graph_manager->addVertex(new_vertex);
graph_manager->addEdge(new_vertex, nearest_vertex, direction_norm);
parent_vertex = new_vertex;
} else {
ROS_WARN("[GlobalGraph] Try to add current state to the graph.");
ExpandGraphReport rep;
expandGraph(graph_manager, first_state, rep);
if (rep.status == ExpandGraphStatus::kSuccess) {
ROS_WARN("[GlobalGraph] Added successfully.");
parent_vertex = rep.vertex_added;
} else {
ROS_WARN("[GlobalGraph] Can not add current state to the global graph.");
return false;
}
}
// Add all remaining vertices of the path.
std::vector<Vertex*> vertex_list;
vertex_list.push_back(parent_vertex);
for (int i = 1; i < path.size(); ++i) {
StateVec new_state;
new_state << path[i].position.x, path[i].position.y, path[i].position.z,
0.0;
Eigen::Vector3d origin(parent_vertex->state[0], parent_vertex->state[1],
parent_vertex->state[2]);
Eigen::Vector3d direction(new_state[0] - origin[0],
new_state[1] - origin[1],
new_state[2] - origin[2]);
double direction_norm = direction.norm();
Vertex* new_vertex =
new Vertex(graph_manager->generateVertexID(), new_state);
// new_vertex->type = vertices[i]->type;
new_vertex->parent = parent_vertex;
new_vertex->distance = parent_vertex->distance + direction_norm;
parent_vertex->children.push_back(new_vertex);
graph_manager->addVertex(new_vertex);
graph_manager->addEdge(new_vertex, parent_vertex, direction_norm);
vertex_list.push_back(new_vertex);
parent_vertex = new_vertex;
}
// Build edges around vertices if possible to get better path.
int n_vertices = 0;
int n_edges = 0;
// Assume the path is verified collision free.
for (int i = 0; i < vertex_list.size(); ++i) {
int num_vertices_added = 0;
int num_edges_added = 0;
ExpandGraphReport rep;
expandGraphEdges(graph_manager, vertex_list[i], rep);
if (rep.status == ExpandGraphStatus::kSuccess) {
n_vertices += num_vertices_added;
n_edges += num_edges_added;
} else {
switch (rep.status) {
case ExpandGraphStatus::kErrorKdTree:
ROS_WARN("Can not add this vertex: kErrorKdTree.");
break;
case ExpandGraphStatus::kErrorCollisionEdge:
ROS_WARN("Can not add this vertex: kErrorCollisionEdge.");
break;
case ExpandGraphStatus::kErrorShortEdge:
ROS_WARN("Can not add this vertex: kErrorShortEdge.");
break;
}
}
}
const bool path_intp_add = true;
const double intp_len = 1.0; // m
if (path_intp_add) {
// Add some intermidiate vertices along the path to densify the global
// graph.
for (int i = 0; i < (vertex_list.size() - 1); ++i) {
Eigen::Vector3d start_vertex(vertex_list[i]->state.x(),
vertex_list[i]->state.y(),
vertex_list[i]->state.z());
Eigen::Vector3d end_vertex(vertex_list[i + 1]->state.x(),
vertex_list[i + 1]->state.y(),
vertex_list[i + 1]->state.z());
Eigen::Vector3d edge_vec = end_vertex - start_vertex;
double edge_length = edge_vec.norm();
if (edge_length <= intp_len) continue;
edge_vec.normalize();
int n_intp = (int)std::ceil(edge_length / intp_len); // segments
Vertex* prev_vertex = vertex_list[i];
double acc_len = 0;
for (int j = 1; j < n_intp; ++j) {
Eigen::Vector3d new_v;
new_v = start_vertex + j * intp_len * edge_vec;
StateVec new_state;
new_state << new_v[0], new_v[1], new_v[2], vertex_list[i]->state[3];
Vertex* new_vertex =
new Vertex(graph_manager->generateVertexID(), new_state);
graph_manager->addVertex(new_vertex);
graph_manager->addEdge(new_vertex, prev_vertex, intp_len);
prev_vertex = new_vertex;
acc_len += intp_len;
}
// Link the last connection
double last_edge_len = edge_length - acc_len;
graph_manager->addEdge(prev_vertex, vertex_list[i + 1], last_edge_len);
}
}
return true;
}
void Rrg::setState(StateVec& state) {
if (!odometry_ready) {
// First time receive the pose/odometry for planning purpose.
// Reset the octomap
ROS_WARN("Received the first odometry, reset the map");
map_manager_->resetMap();
}
current_state_ = state;
odometry_ready = true;
// Clear free space based on current voxel size.
if (planner_trigger_time_ < planning_params_.augment_free_voxels_time) {
map_manager_->augmentFreeBox(
Eigen::Vector3d(current_state_[0], current_state_[1],
current_state_[2]) +
robot_params_.center_offset,
robot_box_size_);
}
if (robot_backtracking_queue_.size()) {
if (robot_backtracking_queue_.size() >= backtracking_queue_max_size) {
robot_backtracking_queue_.pop();
}
robot_backtracking_queue_.emplace(current_state_);
} else {
robot_backtracking_queue_.emplace(state);
}
}
void Rrg::timerCallback(const ros::TimerEvent& event) {
// Re-initialize until get non-zero value.
if (rostime_start_.toSec() == 0) rostime_start_ = ros::Time::now();
if (!odometry_ready) {
ROS_WARN("Planner is waiting for odometry");
return;
}
// Estimate the exploring direction.
// Use the position direction rather than the heading direction.
constexpr int kQueueMaxSize = 10;
constexpr double kAlpha = 0.3; // favor newest paths.
constexpr double kMinDist = 0.75;
if (robot_state_queue_.size()) {
StateVec& last_state = robot_state_queue_.back();
Eigen::Vector3d cur_dir(current_state_[0] - last_state[0],
current_state_[1] - last_state[1],
0.0); // ignore changes in z-axis
if (cur_dir.norm() >= kMinDist) {
double yaw = atan2(cur_dir[1], cur_dir[0]);
double dyaw = yaw - exploring_direction_;
truncateYaw(dyaw);
exploring_direction_ = exploring_direction_ + (1 - kAlpha) * dyaw;
truncateYaw(exploring_direction_);
if (robot_state_queue_.size() >= kQueueMaxSize) {
robot_state_queue_.pop();
}
robot_state_queue_.emplace(current_state_);
}
} else {
robot_state_queue_.emplace(current_state_);
}
// Enforce edges from dometry.
bool enforce_vertex_from_odometry = true;
constexpr double kOdoEnforceLength = 0.5;
if (enforce_vertex_from_odometry) {
while (robot_backtracking_queue_.size()) {
StateVec bt_state = robot_backtracking_queue_.front();
robot_backtracking_queue_.pop();
if (robot_backtracking_prev_ == NULL)
global_graph_->getNearestVertex(&bt_state, &robot_backtracking_prev_);
if (robot_backtracking_prev_) {
Eigen::Vector3d cur_dir(
bt_state[0] - robot_backtracking_prev_->state[0],
bt_state[1] - robot_backtracking_prev_->state[1],
bt_state[2] - robot_backtracking_prev_->state[2]);
double dir_norm = cur_dir.norm();
if (dir_norm >= kOdoEnforceLength) {
Vertex* new_vertex =
new Vertex(global_graph_->generateVertexID(), bt_state);
new_vertex->parent = robot_backtracking_prev_;
new_vertex->distance = robot_backtracking_prev_->distance + dir_norm;
global_graph_->addVertex(new_vertex);
// could increase the distance to limit shortest paths along these
// edges for safety purpose since we don't check the collision
const double kEdgeWeightExtended = 1.0;
global_graph_->addEdge(new_vertex, robot_backtracking_prev_,
dir_norm * kEdgeWeightExtended);
robot_backtracking_prev_ = new_vertex;
}
}
}
}
// Get position from odometry to add more vertices to the graph for homing.
Eigen::Vector3d cur_dir(current_state_[0] - last_state_marker_[0],
current_state_[1] - last_state_marker_[1],
current_state_[2] - last_state_marker_[2]);
constexpr double kOdoUpdateMinLength = kOdoEnforceLength;
if (cur_dir.norm() >= kOdoUpdateMinLength) {
// Add this to the global graph.
const bool add_odometry_to_global_graph = true;
if (add_odometry_to_global_graph) {
StateVec new_state;
new_state = current_state_;
ExpandGraphReport rep;
expandGraph(global_graph_, new_state, rep);
// ROS_INFO("From odometry, added %d vertices and %d edges",
// rep.num_vertices_added, rep.num_edges_added);
}
last_state_marker_ = current_state_;
}
constexpr double kMinLength = 1.0;
Eigen::Vector3d cur_dir1(current_state_[0] - last_state_marker_global_[0],
current_state_[1] - last_state_marker_global_[1],
current_state_[2] - last_state_marker_global_[2]);
if (cur_dir1.norm() >= kMinLength) {
// Instead of adding all odometry to the graph which will increase the graph
// significantly. Let's store them in a database, then add later if
// requires. Get position from odometry to add more vertices to the graph
// for homing.
// constexpr double kMinLength = 1.0;
constexpr double kUpdateRadius = 3.0;
StateVec* state_add = new StateVec(current_state_[0], current_state_[1],
current_state_[2], current_state_[3]);
robot_state_hist_->addState(state_add);
const bool apply_eventE1 = true;
if (apply_eventE1) {
global_graph_->updateVertexTypeInRange(current_state_,
kUpdateRadius); // E1
}
last_state_marker_global_ = current_state_;
}
}
void Rrg::setBoundMode(explorer::BoundModeType bmode) {
constexpr double kNumVerticesRatio = 1.3;
constexpr double kNumEdgesRatio = 1.3;
robot_params_.setBoundMode(bmode);
// Update the robot size for planning.
robot_params_.getPlanningSize(robot_box_size_);
// Change the number of vertices allowed as well. @HACK: any better way to do?
switch (bmode) {
case BoundModeType::kExtendedBound:
planning_num_vertices_max_ = planning_params_.num_vertices_max;
planning_num_edges_max_ = planning_params_.num_edges_max;
break;
case BoundModeType::kRelaxedBound:
planning_num_vertices_max_ =
(int)((double)planning_params_.num_vertices_max * kNumVerticesRatio);
planning_num_edges_max_ =
(int)((double)planning_params_.num_edges_max * kNumEdgesRatio);
break;
case BoundModeType::kMinBound:
planning_num_vertices_max_ =
(int)((double)planning_params_.num_vertices_max * kNumVerticesRatio *
kNumVerticesRatio);
planning_num_edges_max_ = (int)((double)planning_params_.num_edges_max *
kNumEdgesRatio * kNumEdgesRatio);
break;
}
}
bool Rrg::compareAngles(double dir_angle_a, double dir_angle_b, double thres) {
double dyaw = dir_angle_a - dir_angle_b;
if (dyaw > M_PI)
dyaw -= 2 * M_PI;
else if (dyaw < -M_PI)
dyaw += 2 * M_PI;
if (std::abs(dyaw) <= thres) {
return true;
} else {
return false;
}
}
bool Rrg::comparePathWithDirectionApprioximately(
const std::vector<geometry_msgs::Pose>& path, double yaw) {
const double kMinSegmentLen = 2.0;
const double kYawThres = 0.5 * M_PI;
if (path.size() <= 1) return true;
// Get aprpoximate direction.
Eigen::Vector3d root_pos(path[0].position.x, path[0].position.y,
path[0].position.z);
double path_yaw = 0;
for (int i = 1; i < path.size(); ++i) {
Eigen::Vector3d dir_vec;
dir_vec << path[i].position.x - root_pos.x(),
path[i].position.y - root_pos.y(),
0.0; // ignore z
if (dir_vec.norm() > kMinSegmentLen) {
path_yaw = std::atan2(dir_vec.y(), dir_vec.x());
break;
}
}
double dyaw = path_yaw - yaw;
if (dyaw > M_PI)
dyaw -= 2 * M_PI;
else if (dyaw < -M_PI)
dyaw += 2 * M_PI;
const double yaw_thres = 0.5 * M_PI;
if (std::abs(dyaw) <= kYawThres) {
return true;
} else {
return false;
}
}
std::vector<int> Rrg::performShortestPathsClustering(
const std::shared_ptr<GraphManager> graph_manager,
const ShortestPathsReport& graph_rep, std::vector<Vertex*>& vertices,
double dist_threshold, double principle_path_min_length,
bool refinement_enable) {
// Asumme long paths are principle paths.
// Go over one by one from the longest ones.
// Group into clusters based on the normalized DTW distance metric.
// Refine by choosing closest & valid principle path.
// Sort into descending order.
std::sort(vertices.begin(), vertices.end(),
[&graph_manager, &graph_rep](const Vertex* a, const Vertex* b) {
return graph_manager->getShortestDistance(a->id, graph_rep) >
graph_manager->getShortestDistance(b->id, graph_rep);
});
std::vector<std::vector<Eigen::Vector3d>> cluster_paths;
std::vector<int> cluster_ids;
for (int i = 0; i < vertices.size(); ++i) {
std::vector<Eigen::Vector3d> path_cur;
graph_manager->getShortestPath(vertices[i]->id, graph_rep, true, path_cur);
bool found_a_neigbor = false;
for (int j = 0; j < cluster_paths.size(); ++j) {
if (Trajectory::compareTwoTrajectories(path_cur, cluster_paths[j],
dist_threshold)) {
vertices[i]->cluster_id = cluster_ids[j];
found_a_neigbor = true;
break;
}
}
if (!found_a_neigbor) {
// Can not find any neigbor, set this as a new principle path.
cluster_paths.emplace_back(path_cur);
cluster_ids.push_back(vertices[i]->id);
vertices[i]->cluster_id = vertices[i]->id;
}
}
ROS_INFO("Cluster %d paths into %d clusters.", (int)vertices.size(),
(int)cluster_paths.size());
// Refinement step, remove short path and choose closest cluster.
if (refinement_enable) {
// Clean out noisy paths by removing short path.
std::vector<std::vector<Eigen::Vector3d>> cluster_paths_refine;
std::vector<int> cluster_ids_refine;
for (int j = 0; j < cluster_paths.size(); ++j) {
double path_len = Trajectory::getPathLength(cluster_paths[j]);
if (path_len >= principle_path_min_length) {
cluster_paths_refine.push_back(cluster_paths[j]);
cluster_ids_refine.push_back(cluster_ids[j]);
}
}
// Recheck and choose closest one.
int cluster_paths_size = cluster_paths.size();
for (int i = 0; i < vertices.size(); ++i) {
std::vector<Eigen::Vector3d> path_cur;
graph_manager->getShortestPath(vertices[i]->id, graph_rep, true,
path_cur);
double dist_min = std::numeric_limits<double>::infinity();
for (int j = 0; j < cluster_paths_refine.size(); ++j) {
double dist_score = Trajectory::computeDistanceBetweenTwoTrajectories(
path_cur, cluster_paths_refine[j]);
if (dist_min > dist_score) {
dist_min = dist_score;
vertices[i]->cluster_id = cluster_ids_refine[j];
}
}
}
ROS_INFO("Clustering with refinement %d paths into %d clusters.",
(int)vertices.size(), (int)cluster_paths_refine.size());
return cluster_ids_refine;
} else {
return cluster_ids;
}
}
bool Rrg::connectStateToGraph(std::shared_ptr<GraphManager> graph,
StateVec& cur_state, Vertex*& v_added,
double dist_ignore_collision_check) {
Vertex* nearest_vertex = NULL;
if (!graph->getNearestVertex(&cur_state, &nearest_vertex)) return false;
if (nearest_vertex == NULL) return false;
Eigen::Vector3d origin(nearest_vertex->state[0], nearest_vertex->state[1],
nearest_vertex->state[2]);
Eigen::Vector3d direction(cur_state[0] - origin[0], cur_state[1] - origin[1],
cur_state[2] - origin[2]);
double direction_norm = direction.norm();
bool connect_state_to_graph = true;
const double kDelta = 0.05;
if (direction_norm <= kDelta) {
// Add edges only from this vertex.
ExpandGraphReport rep;
expandGraphEdges(graph, nearest_vertex, rep);
v_added = nearest_vertex;
} else if (direction_norm <= std::max(dist_ignore_collision_check,
planning_params_.edge_length_min)) {
// Blindly add a link/vertex to the graph if small radius.
Vertex* new_vertex = new Vertex(graph->generateVertexID(), cur_state);
new_vertex->parent = nearest_vertex;
new_vertex->distance = nearest_vertex->distance + direction_norm;
graph->addVertex(new_vertex);
graph->addEdge(new_vertex, nearest_vertex, direction_norm);
// Add edges only from this vertex.
ExpandGraphReport rep;
expandGraphEdges(graph, new_vertex, rep);
v_added = new_vertex;
} else {
ROS_WARN("[GlobalGraph] Try to add current state to the graph.");
ExpandGraphReport rep;
expandGraph(graph, cur_state, rep);
if (rep.status == ExpandGraphStatus::kSuccess) {
ROS_WARN("[GlobalGraph] Added successfully.");
v_added = rep.vertex_added;
} else {
// Not implemented solution for this case yet.
connect_state_to_graph = false;
ROS_WARN("[GlobalGraph] Can not add current state to graph since: ");
switch (rep.status) {
case ExpandGraphStatus::kErrorKdTree:
ROS_WARN("kErrorKdTree.");
break;
case ExpandGraphStatus::kErrorCollisionEdge:
ROS_WARN("kErrorCollisionEdge.");
break;
case ExpandGraphStatus::kErrorShortEdge:
ROS_WARN("kErrorShortEdge.");
break;
}
}
}
return connect_state_to_graph;
}
double Rrg::getTimeElapsed() {
double time_elapsed = 0.0;
if ((ros::Time::now()).toSec() != 0.0) {
if (rostime_start_.toSec() == 0.0) rostime_start_ = ros::Time::now();
time_elapsed = (double)((ros::Time::now() - rostime_start_).toSec());
}
return time_elapsed;
}
double Rrg::getTimeRemained() {
double time_budget_remaining =
planning_params_.time_budget_limit - getTimeElapsed();
// Check 2 conditions (time budget vs battery) whatever which one comes first.
return std::min(time_budget_remaining, current_battery_time_remaining_);
}
bool Rrg::isRemainingTimeSufficient(const double& time_cost,
double& time_spare) {
const double kTimeDelta = 20; // magic number, extra safety
time_spare = getTimeRemained() - time_cost;
if (time_spare < kTimeDelta) {
ROS_WARN("REACHED TIME LIMIT: BE CAREFUL.");
return false;
}
return true;
}
std::vector<geometry_msgs::Pose> Rrg::runGlobalPlanner(int vertex_id,
bool not_check_frontier,
bool ignore_time) {
// @not_check_frontier: just check if it is feasible (collision-free + time)
// @ignore_time: don't consider time budget.
// Check if exists any frontier in the global graph
// Get the list of current frontiers.
ros::Duration(3.0).sleep(); // sleep to unblock the thread to get update
ros::spinOnce();
START_TIMER(ttime);
std::vector<geometry_msgs::Pose> ret_path;
ret_path.clear();
// Check if the global planner exists
if (global_graph_->getNumVertices() <= 1) {
ROS_WARN("[GlobalGraph] Graph is empty, nothing to search.");
return ret_path;
}
// Check if the vertex id exists
if ((vertex_id < 0) || (vertex_id >= global_graph_->getNumVertices())) {
ROS_WARN(
"[GlobalGraph] Vertex ID doesn't exist, plz consider IDs in the range "
"[0-%d].",
global_graph_->getNumVertices() - 1);
return ret_path;
}
// Check if the time endurance is still available.
if (!ignore_time) {
if (getTimeRemained() <= 0.0) {
ROS_WARN("[Global] RAN OUT OF TIME --> STOP HERE.");
return ret_path;
}
}
// Check if exists any frontiers in the graph.
// Re-update all the frontiers based on the volumetric gain.
std::vector<Vertex*> global_frontiers;
int num_vertices = global_graph_->getNumVertices();
ROS_INFO("Re-check all frontiers.");
global_frontiers.clear();
for (int id = 0; id < num_vertices; ++id) {
if (global_graph_->getVertex(id)->type == VertexType::kFrontier) {
Vertex* v = global_graph_->getVertex(id);
computeVolumetricGainRayModelNoBound(v->state, v->vol_gain);
if (!v->vol_gain.is_frontier)
v->type = VertexType::kUnvisited;
else
global_frontiers.push_back(global_graph_->getVertex(id));
}
}
ROS_INFO("Currently have %d frontiers in the global graph.",
(int)global_frontiers.size());
if ((!not_check_frontier) && (global_frontiers.size() <= 0)) {
ROS_INFO(
"No frontier exists --> Could call HOMING instead if fully explored.");
return ret_path;
}
// Let's try to add current state to the global graph.
ROS_WARN("Trying to add new vertex from current position.");
StateVec cur_state;
cur_state << current_state_[0], current_state_[1], current_state_[2],
current_state_[3];
Vertex* link_vertex = NULL;
const double kRadiusLimit = 1.5; // 0.5
bool connected_to_graph =
connectStateToGraph(global_graph_, cur_state, link_vertex, kRadiusLimit);
if (!connected_to_graph) {
ROS_WARN("Cannot add the state to the global graph.");
return ret_path;
}
ROS_WARN(
"Added current state to the graph. Start searching for the global path "
"now.");
// Get Dijsktra path from home to all.
if (!global_graph_->findShortestPaths(global_graph_rep_)) {
ROS_ERROR("[GlobalGraph] Failed to find shortest path.");
return ret_path;
}
// Get Dijsktra path from current to all.
ShortestPathsReport frontier_graph_rep;
if (!global_graph_->findShortestPaths(link_vertex->id, frontier_graph_rep)) {
ROS_ERROR("[GlobalGraph] Failed to find shortest path.");
return ret_path;
}
// Check if the planner should find the best vertex automatically or manually
double best_gain = -1.0;
Vertex* best_frontier = NULL;
if (vertex_id) {
// Manual mode
// Just need to check if it is feasible
std::vector<int> current_to_target_path_id;
std::vector<int> target_to_home_path_id;
double current_to_target_distance;
double target_to_home_distance;
global_graph_->getShortestPath(vertex_id, frontier_graph_rep, true,
current_to_target_path_id);
global_graph_->getShortestPath(vertex_id, global_graph_rep_, false,
target_to_home_path_id);
current_to_target_distance =
global_graph_->getShortestDistance(vertex_id, frontier_graph_rep);
target_to_home_distance =
global_graph_->getShortestDistance(vertex_id, global_graph_rep_);
// Estimate time
double time_remaining = getTimeRemained();
double time_to_target =
current_to_target_distance / planning_params_.v_homing_max;
double time_to_home =
target_to_home_distance / planning_params_.v_homing_max;
double time_cost = 0;
if (!ignore_time) {
ROS_INFO("[Global] Time remaining: %f (sec)", time_remaining);
time_cost += time_to_target;
ROS_INFO("[Global] Time to [%3d]: %f (sec)", vertex_id, time_to_target);
if (planning_params_.auto_homing_enable) {
time_cost += time_to_home;
ROS_INFO("[Global] Time to home : %f (sec)", time_to_home);
}
}
double time_spare = 0;
if (!isRemainingTimeSufficient(time_cost, time_spare)) {
ROS_WARN("[Global] Not enough time to go the vertex [%d]", vertex_id);
ROS_WARN(
"[Global] Consider change to another ID or set ignore_time to True");
return ret_path;
}
best_frontier = global_graph_->getVertex(vertex_id);
best_gain = 1.0;
} else {
// Auto mode
// Get list of feasible frontiers by checking remaining time.
// Leave the check empty for now since it relate to time budget setting.
std::vector<Vertex*> feasible_global_frontiers;
for (auto& f : global_frontiers) {
if (ignore_time)
feasible_global_frontiers.push_back(f);
else {
// get gain.
std::vector<int> current_to_frontier_path_id;
std::vector<int> frontier_to_home_path_id;
double current_to_frontier_distance;
double frontier_to_home_distance;
global_graph_->getShortestPath(f->id, frontier_graph_rep, true,
current_to_frontier_path_id);
global_graph_->getShortestPath(f->id, global_graph_rep_, false,
frontier_to_home_path_id);
current_to_frontier_distance =
global_graph_->getShortestDistance(f->id, frontier_graph_rep);
frontier_to_home_distance =
global_graph_->getShortestDistance(f->id, global_graph_rep_);
double time_remaining = getTimeRemained();
double time_to_target =
current_to_frontier_distance / planning_params_.v_homing_max;
double time_to_home =
frontier_to_home_distance / planning_params_.v_homing_max;
double time_cost = time_to_target + planning_params_.auto_homing_enable
? time_to_home
: 0;
double time_spare = 0;
if (isRemainingTimeSufficient(time_cost, time_spare)) {
feasible_global_frontiers.push_back(f);
}
}
}
ROS_INFO("Get %d feasible frontiers from global frontiers.",
(int)feasible_global_frontiers.size());
if (feasible_global_frontiers.size() <= 0) {
ROS_INFO(
"No feasible frontier exists --> Call HOMING instead if fully "
"explored.");
return ret_path;
}
// Compute exploration gain.
std::unordered_map<int, double> frontier_exp_gain;
for (int i = 0; i < feasible_global_frontiers.size(); ++i) {
Vertex* f = feasible_global_frontiers[i];
// get gain.
std::vector<int> current_to_frontier_path_id;
std::vector<int> frontier_to_home_path_id;
double current_to_frontier_distance;
double frontier_to_home_distance;
global_graph_->getShortestPath(f->id, frontier_graph_rep, true,
current_to_frontier_path_id);
global_graph_->getShortestPath(f->id, global_graph_rep_, false,
frontier_to_home_path_id);
current_to_frontier_distance =
global_graph_->getShortestDistance(f->id, frontier_graph_rep);
frontier_to_home_distance =
global_graph_->getShortestDistance(f->id, global_graph_rep_);
// Duplication from above but easier to understand.
double time_to_target =
current_to_frontier_distance / planning_params_.v_homing_max;
double time_to_home =
frontier_to_home_distance / planning_params_.v_homing_max;
double time_cost = time_to_target + planning_params_.auto_homing_enable
? time_to_home
: 0;
double time_spare = 0;
if (!isRemainingTimeSufficient(time_cost, time_spare)) {
time_spare = 1;
}
const double kGDistancePenalty = 0.01;
double exp_gain = f->vol_gain.gain *
exp(-kGDistancePenalty * current_to_frontier_distance);
if (!ignore_time) exp_gain *= time_spare;
frontier_exp_gain[f->id] = exp_gain;
if (exp_gain > best_gain) {
best_gain = exp_gain;
best_frontier = f;
}
}
// Rank from the best one.
// Sort into descending order.
std::sort(feasible_global_frontiers.begin(),
feasible_global_frontiers.end(),
[&frontier_exp_gain](const Vertex* a, const Vertex* b) {
return frontier_exp_gain[a->id] > frontier_exp_gain[b->id];
});
}
std::vector<int> current_to_frontier_path_id;
std::vector<int> frontier_to_home_path_id;
if (best_gain >= 0) {
ROS_WARN("Found the best frontier to go is: %d", best_frontier->id);
global_graph_->getShortestPath(best_frontier->id, frontier_graph_rep, true,
current_to_frontier_path_id);
global_graph_->getShortestPath(best_frontier->id, global_graph_rep_, false,
frontier_to_home_path_id);
int current_to_frontier_path_id_size = current_to_frontier_path_id.size();
for (int i = 0; i < current_to_frontier_path_id_size; ++i) {
StateVec state =
global_graph_->getVertex(current_to_frontier_path_id[i])->state;
tf::Quaternion quat;
quat.setEuler(0.0, 0.0, state[3]);
tf::Vector3 origin(state[0], state[1], state[2]);
tf::Pose poseTF(quat, origin);
geometry_msgs::Pose pose;
tf::poseTFToMsg(poseTF, pose);
ret_path.push_back(pose);
}
} else {
ROS_WARN(
"Could not find any positive gain (Should not happen) --> Try with "
"HOMING.");
return ret_path;
}
// Set the heading angle tangent with the moving direction,
// from the second waypoint; the first waypoint keeps the same direction.
if (planning_params_.yaw_tangent_correction) {
for (int i = 0; i < (ret_path.size() - 1); ++i) {
Eigen::Vector3d vec(ret_path[i + 1].position.x - ret_path[i].position.x,
ret_path[i + 1].position.y - ret_path[i].position.y,
ret_path[i + 1].position.z - ret_path[i].position.z);
double yaw = std::atan2(vec[1], vec[0]);
tf::Quaternion quat;
quat.setEuler(0.0, 0.0, yaw);
ret_path[i + 1].orientation.x = quat.x();
ret_path[i + 1].orientation.y = quat.y();
ret_path[i + 1].orientation.z = quat.z();
ret_path[i + 1].orientation.w = quat.w();
}
}
// Modify path if required
if (planning_params_.path_safety_enhance_enable) {
ros::Time mod_time;
START_TIMER(mod_time);
std::vector<geometry_msgs::Pose> mod_path;
if (improveFreePath(ret_path, mod_path)) {
ret_path = mod_path;
}
double dmod_time = GET_ELAPSED_TIME(mod_time);
ROS_WARN("Compute an aternate path for homing in %f(s)", dmod_time);
visualization_->visualizeModPath(mod_path);
}
visualization_->visualizeGlobalPaths(
global_graph_, current_to_frontier_path_id, frontier_to_home_path_id);
double dtime = GET_ELAPSED_TIME(ttime);
ROS_WARN("runGlobalPlanner costs: %f (s)", dtime);
visualization_->visualizeGlobalGraph(global_graph_);
visualization_->visualizeRefPath(ret_path);
return ret_path;
}
void Rrg::addGeofenceAreas(const geometry_msgs::PolygonStamped& polygon_msgs) {
if ((planning_params_.geofence_checking_enable) && (planner_trigger_time_)) {
// Check if we need to convert to global coordinate to be compatible
// with the whole planner.
if (!polygon_msgs.header.frame_id.compare(
planning_params_.global_frame_id)) {
geofence_manager_->addGeofenceArea(polygon_msgs.polygon);
} else {
geometry_msgs::Polygon polygon;
// Look up the tf.
tf::StampedTransform tf_to_global;
tf::TransformListener listener;
try {
listener.waitForTransform(planning_params_.global_frame_id,
polygon_msgs.header.frame_id, ros::Time(0),
ros::Duration(0.1)); // this should be fast.
listener.lookupTransform(planning_params_.global_frame_id,
polygon_msgs.header.frame_id, ros::Time(0),
tf_to_global);
for (int i = 0; i < polygon_msgs.polygon.points.size(); ++i) {
tf::Vector3 poly_in_global;
poly_in_global.setValue(polygon_msgs.polygon.points[i].x,
polygon_msgs.polygon.points[i].y,
polygon_msgs.polygon.points[i].z);
poly_in_global = tf_to_global * poly_in_global;
geometry_msgs::Point32 p32;
p32.x = poly_in_global.x();
p32.y = poly_in_global.y();
p32.z = poly_in_global.z();
polygon.points.push_back(p32);
}
geofence_manager_->addGeofenceArea(polygon);
} catch (tf::TransformException ex) {
ROS_WARN(
"Could not look up TF from polygon frame [%s] to the global frame "
"[%s].",
polygon_msgs.header.frame_id.c_str(),
planning_params_.global_frame_id.c_str());
}
}
}
}
bool Rrg::setExpMode(planner_msgs::PlanningMode& exp_mode) {
PlanningModeType pmode = (PlanningModeType)exp_mode.mode;
if ((pmode == PlanningModeType::kVerticalExploration) &&
(!random_sampler_vertical_.isReady)) {
ROS_WARN(
"No setting for vertical exp mode --> cannot switch to vertical "
"mode.");
return false;
}
planning_params_.setPlanningMode((PlanningModeType)exp_mode.mode);
return true;
}
bool Rrg::loadGraph(const std::string& path) {
global_graph_->loadGraph(path);
visualization_->visualizeGlobalGraph(global_graph_);
return true;
}
bool Rrg::saveGraph(const std::string& path) {
visualization_->visualizeGlobalGraph(global_graph_);
global_graph_->saveGraph(path);
return true;
}
void Rrg::setGlobalFrame(std::string frame_id) {
// Mainly use to set the frame_id for visualization.
if (!frame_id.empty()) visualization_->setGlobalFrame(frame_id);
}
RobotStateHistory::RobotStateHistory() {
kd_tree_ = NULL;
reset();
}
void RobotStateHistory::reset() {
// Reset kdtree first.
if (kd_tree_) kd_free(kd_tree_);
kd_tree_ = kd_create(3);
}
void RobotStateHistory::addState(StateVec* s) {
kd_insert3(kd_tree_, s->x(), s->y(), s->z(), s);
state_hist_.push_back(s);
}
bool RobotStateHistory::getNearestState(const StateVec* state,
StateVec** s_res) {
// it seems kdtree lib can not deal with empty tree, put a guard check here.
if (state_hist_.size() == 0) return false;
kdres* nearest = kd_nearest3(kd_tree_, state->x(), state->y(), state->z());
if (kd_res_size(nearest) <= 0) {
kd_res_free(nearest);
return false;
}
*s_res = (StateVec*)kd_res_item_data(nearest);
kd_res_free(nearest);
return true;
}
bool RobotStateHistory::getNearestStates(const StateVec* state, double range,
std::vector<StateVec*>* s_res) {
// Notice that this might include the same vertex in the result.
// if that vertex is added to the tree before.
// Use the distance 0 or small threshold to filter out.
if (state_hist_.size() == 0) return false;
kdres* neighbors =
kd_nearest_range3(kd_tree_, state->x(), state->y(), state->z(), range);
int neighbors_size = kd_res_size(neighbors);
if (neighbors_size <= 0) return false;
s_res->clear();
for (int i = 0; i < neighbors_size; ++i) {
StateVec* new_neighbor = (StateVec*)kd_res_item_data(neighbors);
s_res->push_back(new_neighbor);
if (kd_res_next(neighbors) <= 0) break;
}
kd_res_free(neighbors);
return true;
}
bool RobotStateHistory::getNearestStateInRange(const StateVec* state,
double range, StateVec** s_res) {
if (state_hist_.size() == 0) return false;
kdres* nearest = kd_nearest3(kd_tree_, state->x(), state->y(), state->z());
if (kd_res_size(nearest) <= 0) {
kd_res_free(nearest);
return false;
}
*s_res = (StateVec*)kd_res_item_data(nearest);
Eigen::Vector3d dist;
dist << state->x() - (*s_res)->x(), state->y() - (*s_res)->y(),
state->z() - (*s_res)->z();
kd_res_free(nearest);
if (dist.norm() > range) return false;
return true;
}
} // namespace gbplanner
} // namespace explorer
| [
"[email protected]"
] | |
431a8b2e398d68a5f99d1ca71b1bcdb6535ec347 | efa4bab51a67ae2b131807a5b7e4f6b6619906cd | /HW2/test_stepper/test_stepper.ino | 8709c803570afaf4e67d1deca296f0a3143bf039 | [] | no_license | SonamYeshe/ENME808M-Medical-Robotics | dab46cc5f0d3861bc1352951dd0e1a2c2101ccc2 | 8f113714ae40bd034a0ca1a6b270a35a2dfd8d70 | refs/heads/master | 2020-06-05T14:02:47.980450 | 2019-06-18T03:06:32 | 2019-06-18T03:06:32 | 192,455,326 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 993 | ino | /*
Stepper Motor Control - one revolution
This program drives a unipolar or bipolar stepper motor.
The motor is attached to digital pins 8 - 11 of the Arduino.
The motor should revolve one revolution in one direction, then
one revolution in the other direction.
Created 11 Mar. 2007
Modified 30 Nov. 2009
by Tom Igoe
*/
#include <Stepper.h>
const int stepsPerRevolution = 200; // change this to fit the number of steps per revolution
// for your motor
// initialize the stepper library on pins 8 through 11:
Stepper myStepper(stepsPerRevolution, 2, 3, 4, 5);
void setup() {
// set the speed at 60 rpm:
myStepper.setSpeed(60);
// initialize the serial port:
Serial.begin(9600);
}
void loop() {
// step one revolution in one direction:
Serial.println("clockwise");
myStepper.step(stepsPerRevolution);
delay(500);
// step one revolution in the other direction:
Serial.println("counterclockwise");
myStepper.step(-stepsPerRevolution);
delay(500);
}
| [
"[email protected]"
] | |
bda12b041a0e811e4952b7f8e2c23b1370a9d052 | de9804fc9c17b5994fdd8699b5c94f7edadbc6ba | /c++/self_study/baek_2439.cpp | 179403e35788fbceb192020c5ac5a0c63ba37f0f | [] | no_license | jianny-lee/algorithm-study | 7cafd41f42727b43d52d11888faac06e6aa5e3a9 | 3cab9d7ad6f6736f95e5476c0144a1eb28e97485 | refs/heads/master | 2021-12-10T13:08:04.853210 | 2021-08-13T14:20:24 | 2021-08-13T14:20:24 | 222,359,938 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 297 | cpp | #include <iostream>
using namespace std;
int main(){
int num;
char star = '*';
cin >> num;
int cnt=0;
for(int i=0;i<num;i++){
for(int j=0;j<num-(i+1);j++)
cout << " ";
for(int j=0;j<i+1;j++)
cout << star;
cout << "\n";
}
} | [
"[email protected]"
] | |
574906b288b93df6075f5e69c1410d6dd561542a | 8e672fdc1a7ee0e57914afc7a10ff0fa3a64a70c | /mechanics/src/joints/JointStopR.cpp | 5dd244b3b578413825d35292cbcd0ae95d5437f9 | [
"LicenseRef-scancode-unknown-license-reference",
"Apache-2.0"
] | permissive | michelanthony/CloneSiconosMaster | d5ddbafde12a19694fa0b8faba803c7bfcd2b49c | c1ba3525d21551fcb7226192be451cd6760dd4c0 | refs/heads/master | 2020-03-06T20:28:35.540643 | 2018-03-27T23:19:07 | 2018-03-27T23:19:07 | 127,053,929 | 2 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 4,726 | cpp | /* Siconos is a program dedicated to modeling, simulation and control
* of non smooth dynamical systems.
*
* Copyright 2016 INRIA.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/*! \file JointStopR.cpp
*/
#include "JointStopR.hpp"
#include <NewtonEulerDS.hpp>
#include <Interaction.hpp>
#include <boost/math/quaternion.hpp>
#include <BlockVector.hpp>
#include <cfloat>
#include <iostream>
// #define DEBUG_BEGIN_END_ONLY
// #define DEBUG_STDOUT
// #define DEBUG_MESSAGES
#include "debug.h"
/** Initialize a joint stop for a common case: a single axis with a
* single stop, either positive or negative. For use with
* NewtonImpactNSL. */
JointStopR::JointStopR(SP::NewtonEulerJointR joint, double pos, bool dir,
unsigned int axis)
: NewtonEulerR()
, _joint(joint)
, _axis(std11::make_shared< std::vector<unsigned int> >())
, _pos(std11::make_shared<SiconosVector>(1))
, _dir(std11::make_shared<SiconosVector>(1))
{
_axis->push_back(axis);
_pos->setValue(0, pos);
_dir->setValue(0, dir ? -1 : 1);
_axisMin = axis;
_axisMax = axis;
assert( (_axisMax - _axisMin + 1) <= _joint->numberOfDoF() );
}
/** Initialize a multidimensional joint stop, e.g. the cone stop on
* a ball joint. For use with NewtonImpactFrictionNSL size 2 or 3. */
JointStopR::JointStopR(SP::NewtonEulerJointR joint, SP::SiconosVector pos,
SP::SiconosVector dir, SP::UnsignedIntVector axes)
: NewtonEulerR()
, _joint(joint)
, _axis(axes)
, _pos(pos)
, _dir(dir)
{
_axisMin = 100;
_axisMax = 0;
for (unsigned int i=0; i < _axis->size(); i++)
{
if ((*_axis)[i] > _axisMax) _axisMax = (*_axis)[i];
if ((*_axis)[i] < _axisMin) _axisMin = (*_axis)[i];
}
assert( (_axisMax - _axisMin + 1) <= _joint->numberOfDoF() );
}
#if 0 // Disabled, see JointStopR.hpp. Use multiple JointStopR instead.
/** Initialize a joint stop for a common case: a single axis with a
* double stop, one positive and one negative. */
JointStopR::JointStopR(SP::NewtonEulerJointR joint, double pos, double neg,
unsigned int axis)
: NewtonEulerR()
, _joint(joint)
, _axis(std11::make_shared< std::vector<unsigned int> >())
, _pos(std11::make_shared<SiconosVector>(2))
, _dir(std11::make_shared<SiconosVector>(2))
{
_axis->push_back(axis);
_axis->push_back(axis);
_pos->setValue(0, pos);
_pos->setValue(1, neg);
_dir->setValue(0, 1);
_dir->setValue(1, -1);
_axisMin = axis;
_axisMax = axis;
assert( (_axisMax - _axisMin + 1) <= _joint->numberOfDoF() );
}
#endif
void JointStopR::computeh(double time, BlockVector& q0, SiconosVector& y)
{
// Common cases optimisation
bool case_onestop = y.size()==1;
bool case_posneg = y.size()==2 && (*_axis)[0] == (*_axis)[1];
if (case_onestop || case_posneg)
{
_joint->computehDoF(time, q0, y, (*_axis)[0]);
y.setValue(0, (y.getValue(0) - _pos->getValue(0)) * _dir->getValue(0));
if (case_posneg)
y.setValue(1, (y.getValue(0) - _pos->getValue(1)) * _dir->getValue(1));
return;
}
// Get h for each relevant axis
SiconosVector tmp_y(_axisMax - _axisMin + 1);
_joint->computehDoF(time, q0, tmp_y, _axisMin);
// Copy and scale each stop for its axis/position/direction
for (unsigned int i=0; i < y.size(); i++) {
y.setValue(i, (tmp_y.getValue((*_axis)[i])
- _pos->getValue(i))*_dir->getValue(i));
}
}
void JointStopR::computeJachq(double time, Interaction& inter, SP::BlockVector q0)
{
unsigned int n = _axisMax - _axisMin + 1;
if (!_jachqTmp || !(_jachqTmp->size(1) == q0->size() &&
_jachqTmp->size(0) == n))
{
_jachqTmp = std11::make_shared<SimpleMatrix>(n, q0->size());
}
// Compute the jacobian for the required range of axes
_joint->computeJachqDoF(time, inter, q0, *_jachqTmp, _axisMin);
// Copy indicated axes into the stop jacobian, possibly flipped for negative stops
for (unsigned int i=0; i<_jachq->size(0); i++)
for (unsigned int j=0; j<_jachq->size(1); j++)
_jachq->setValue(i,j,
_jachqTmp->getValue((*_axis)[i]-_axisMin,j) * _dir->getValue(i));
}
unsigned int JointStopR::numberOfConstraints()
{
return _axis->size();
}
| [
"[email protected]"
] | |
faa4601f40b120fdd0f3e7ef0fdba0375670aa9c | e440f64a8de17147f11873a999aa8e7d9acc4a0d | /Source/TheLast/Private/SystemWeapon/BaseDamageBox.cpp | d667b27df9d67c0095d9b193f785050d846a25d6 | [] | no_license | NiJiang66/TheLast | 18b2ca6809c5a8911856b6f7cc8850364febd1d9 | 437359c130040dc242c9beb3056d044eb064156a | refs/heads/master | 2020-08-20T10:34:33.542378 | 2019-10-21T16:12:50 | 2019-10-21T16:12:50 | 216,012,474 | 0 | 0 | null | 2019-10-21T16:20:13 | 2019-10-18T11:50:18 | C# | UTF-8 | C++ | false | false | 1,845 | cpp | #include "BaseDamageBox.h"
ABaseDamageBox::ABaseDamageBox()
{
DamgeCheckBox = CreateDefaultSubobject<UBoxComponent>(TEXT("Dmg Check"));
}
TArray<AActor*> ABaseDamageBox::BoxCheck(FVector CausorLocation,FVector FwdLocationOffset, FVector BoundsScale, TSubclassOf<AActor> ClassToCheck)
{
DamgeCheckBox->SetWorldTransform(this->GetTransform());
DamgeCheckBox->SetWorldLocation(CausorLocation + FwdLocationOffset);
DamgeCheckBox->SetWorldScale3D(BoundsScale);
DamgeCheckBox->SetBoxExtent(FVector(120.f, 120.f, 160.f));
TArray<AActor*> Res;
DamgeCheckBox->GetOverlappingActors(Res, ClassToCheck);
DelayedDestory();
return Res;
}
void ABaseDamageBox::DelayedDestory()
{
if (GetWorld()) {
GetWorld()->GetTimerManager().SetTimer(DestoryHandle, this, &ABaseDamageBox::DestoryThis, .2f, false);
}
}
void ABaseDamageBox::DestoryThis()
{
GetWorld()->GetTimerManager().ClearTimer(DestoryHandle);
this->Destroy();
}
ABaseDamageSphere::ABaseDamageSphere()
{
DamgeCheckSphere = CreateDefaultSubobject<USphereComponent>(TEXT("Dmg Check"));
}
TArray<AActor*> ABaseDamageSphere::SphereCheck(FVector CausorLocation, FVector FwdLocationOffset, FVector BoundsScale, TSubclassOf<AActor> ClassToCheck)
{
DamgeCheckSphere->SetWorldTransform(this->GetTransform());
DamgeCheckSphere->SetWorldLocation(CausorLocation + FwdLocationOffset);
DamgeCheckSphere->SetWorldScale3D(BoundsScale);
DamgeCheckSphere->SetSphereRadius(60.f);
TArray<AActor*> Res;
DamgeCheckSphere->GetOverlappingActors(Res, ClassToCheck);
DelayedDestory();
return Res;
}
void ABaseDamageSphere::DelayedDestory()
{
if (GetWorld()) {
GetWorld()->GetTimerManager().SetTimer(DestoryHandle, this, &ABaseDamageSphere::DestoryThis, .2f, false);
}
}
void ABaseDamageSphere::DestoryThis()
{
GetWorld()->GetTimerManager().ClearTimer(DestoryHandle);
this->Destroy();
}
| [
"[email protected]"
] | |
eda67d431b53144fc6999d47c14c73afa3a3916a | 2a9213024770a6c6c6b305bf3cf45f44e6398d47 | /caf/libcaf_io/caf/io/basp/instance.hpp | 7b271f7b111577a75c678ff75b5a930515e52b01 | [
"Unlicense"
] | permissive | wissunpower/WeizenbierGame | 195d36e7a32485dc76f06c2b0d5c11ee6d5b4a60 | 34f027c43055dfa6b05e62ca0b6c31271af013f3 | refs/heads/main | 2023-08-06T06:44:36.240176 | 2021-09-29T07:34:29 | 2021-09-29T07:34:29 | 390,057,582 | 0 | 0 | Unlicense | 2021-09-26T16:22:57 | 2021-07-27T16:43:06 | C++ | UTF-8 | C++ | false | false | 8,060 | hpp | // This file is part of CAF, the C++ Actor Framework. See the file LICENSE in
// the main distribution directory for license terms and copyright or visit
// https://github.com/actor-framework/actor-framework/blob/master/LICENSE.
#pragma once
#include <limits>
#include "caf/actor_system_config.hpp"
#include "caf/byte_buffer.hpp"
#include "caf/callback.hpp"
#include "caf/detail/io_export.hpp"
#include "caf/detail/worker_hub.hpp"
#include "caf/error.hpp"
#include "caf/io/basp/connection_state.hpp"
#include "caf/io/basp/header.hpp"
#include "caf/io/basp/message_queue.hpp"
#include "caf/io/basp/message_type.hpp"
#include "caf/io/basp/routing_table.hpp"
#include "caf/io/basp/worker.hpp"
#include "caf/io/middleman.hpp"
#include "caf/variant.hpp"
namespace caf::io::basp {
/// @addtogroup BASP
/// @{
/// Describes a protocol instance managing multiple connections.
class CAF_IO_EXPORT instance {
public:
/// Provides a callback-based interface for certain BASP events.
class CAF_IO_EXPORT callee {
public:
// -- constructors, destructors, and assignment operators ------------------
explicit callee(actor_system& sys, proxy_registry::backend& backend);
virtual ~callee();
// -- pure virtual functions -----------------------------------------------
/// Called if a server handshake was received and
/// the connection to `nid` is established.
virtual void finalize_handshake(const node_id& nid, actor_id aid,
std::set<std::string>& sigs)
= 0;
/// Called whenever a direct connection was closed or a
/// node became unreachable for other reasons *before*
/// this node gets erased from the routing table.
/// @warning The implementing class must not modify the
/// routing table from this callback.
virtual void purge_state(const node_id& nid) = 0;
/// Called whenever a remote node created a proxy
/// for one of our local actors.
virtual void proxy_announced(const node_id& nid, actor_id aid) = 0;
/// Called whenever BASP learns the ID of a remote node
/// to which it does not have a direct connection.
virtual void
learned_new_node_directly(const node_id& nid, bool was_known_indirectly)
= 0;
/// Called whenever BASP learns the ID of a remote node
/// to which it does not have a direct connection.
virtual void learned_new_node_indirectly(const node_id& nid) = 0;
/// Called if a heartbeat was received from `nid`
virtual void handle_heartbeat() = 0;
/// Returns the current CAF scheduler context.
virtual execution_unit* current_execution_unit() = 0;
/// Returns the actor namespace associated to this BASP protocol instance.
proxy_registry& proxies() {
return namespace_;
}
/// Returns a reference to the sent buffer.
virtual byte_buffer& get_buffer(connection_handle hdl) = 0;
/// Flushes the underlying write buffer of `hdl`.
virtual void flush(connection_handle hdl) = 0;
/// Returns a handle to the callee actor.
virtual strong_actor_ptr this_actor() = 0;
protected:
proxy_registry namespace_;
};
/// Describes a function object responsible for writing
/// the payload for a BASP message.
using payload_writer = callback<bool(binary_serializer&)>;
/// Describes a callback function object for `remove_published_actor`.
using removed_published_actor
= callback<void(const strong_actor_ptr&, uint16_t)>;
instance(abstract_broker* parent, callee& lstnr);
/// Handles received data and returns a config for receiving the
/// next data or `none` if an error occured.
connection_state handle(execution_unit* ctx,
new_data_msg& dm, header& hdr, bool is_payload);
/// Sends heartbeat messages to all valid nodes those are directly connected.
void handle_heartbeat(execution_unit* ctx);
/// Returns a route to `target` or `none` on error.
optional<routing_table::route> lookup(const node_id& target);
/// Flushes the underlying buffer of `path`.
void flush(const routing_table::route& path);
/// Sends a BASP message and implicitly flushes the output buffer of `r`.
/// This function will update `hdr.payload_len` if a payload was written.
void write(execution_unit* ctx, const routing_table::route& r, header& hdr,
payload_writer* writer = nullptr);
/// Adds a new actor to the map of published actors.
void add_published_actor(uint16_t port, strong_actor_ptr published_actor,
std::set<std::string> published_interface);
/// Removes the actor currently assigned to `port`.
size_t
remove_published_actor(uint16_t port, removed_published_actor* cb = nullptr);
/// Removes `whom` if it is still assigned to `port` or from all of its
/// current ports if `port == 0`.
size_t remove_published_actor(const actor_addr& whom, uint16_t port,
removed_published_actor* cb = nullptr);
/// Returns `true` if a path to destination existed, `false` otherwise.
bool dispatch(execution_unit* ctx, const strong_actor_ptr& sender,
const std::vector<strong_actor_ptr>& forwarding_stack,
const node_id& dest_node, uint64_t dest_actor, uint8_t flags,
message_id mid, const message& msg);
/// Returns the actor namespace associated to this BASP protocol instance.
proxy_registry& proxies() {
return callee_.proxies();
}
/// Returns the routing table of this BASP instance.
routing_table& tbl() {
return tbl_;
}
/// Stores the address of a published actor along with its publicly
/// visible messaging interface.
using published_actor = std::pair<strong_actor_ptr, std::set<std::string>>;
/// Maps ports to addresses and interfaces of published actors.
using published_actor_map = std::unordered_map<uint16_t, published_actor>;
/// Returns the current mapping of ports to addresses
/// and interfaces of published actors.
const published_actor_map& published_actors() const {
return published_actors_;
}
/// Writes a header followed by its payload to `storage`.
static void write(execution_unit* ctx, byte_buffer& buf, header& hdr,
payload_writer* pw = nullptr);
/// Writes the server handshake containing the information of the
/// actor published at `port` to `buf`. If `port == none` or
/// if no actor is published at this port then a standard handshake is
/// written (e.g. used when establishing direct connections on-the-fly).
void write_server_handshake(execution_unit* ctx, byte_buffer& out_buf,
optional<uint16_t> port);
/// Writes the client handshake to `buf`.
void write_client_handshake(execution_unit* ctx, byte_buffer& buf);
/// Writes an `announce_proxy` to `buf`.
void write_monitor_message(execution_unit* ctx, byte_buffer& buf,
const node_id& dest_node, actor_id aid);
/// Writes a `kill_proxy` to `buf`.
void
write_down_message(execution_unit* ctx, byte_buffer& buf,
const node_id& dest_node, actor_id aid, const error& rsn);
/// Writes a `heartbeat` to `buf`.
void write_heartbeat(execution_unit* ctx, byte_buffer& buf);
const node_id& this_node() const {
return this_node_;
}
detail::worker_hub<worker>& hub() {
return hub_;
}
message_queue& queue() {
return queue_;
}
actor_system& system() {
return callee_.proxies().system();
}
const actor_system_config& config() {
return system().config();
}
connection_state handle(execution_unit* ctx, connection_handle hdl,
header& hdr, byte_buffer* payload);
private:
void forward(execution_unit* ctx, const node_id& dest_node, const header& hdr,
byte_buffer& payload);
routing_table tbl_;
published_actor_map published_actors_;
node_id this_node_;
callee& callee_;
message_queue queue_;
detail::worker_hub<worker> hub_;
};
/// @}
} // namespace caf::io::basp
| [
"[email protected]"
] | |
8b6d2f05a526f72884c4c9bb4ff5cf088cd28402 | c74bb5cb747d86fbac6fc98efb61313c5a7e5fa2 | /Interview-Question-Practice/Stack_With_MinValue.cpp | fbb092ca1f4f07a7bfe8fcd5c2e9cc87b62b7326 | [] | no_license | myTeemous/Interview-Question-Practice | 6c56bf494fe1ca8e09faac79725ebbe94fc5fea8 | 547eaab2879b7d37f456521e5012c79ae2042b77 | refs/heads/master | 2020-04-17T17:20:01.720918 | 2019-01-28T08:38:36 | 2019-01-28T08:38:36 | 166,778,156 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,134 | cpp | #include <iostream>
using namespace std;
/*
Implementation of a typical stack that also keeps track of the minimum value in the stack.
Each node has a minValue. The values of the subsequent nodes pushed onto the stack are
compared to the minValue of the previous node. If value <= minValue then value will be
stored as the minValue of the node being pushed onto the stack. This ensures that you don't
have to search for the minValue everytime you pop from the stack.
--------------------------------------------------------------------------------------------
The operations of the stack, push, pop, isEmpty, and getMin are all O(1) time.
*/
class Stack {
struct Node {
int _value;
int _minValue;
Node* _next;
Node(int value, int minValue, Node* next = NULL):
_value(value), _minValue(minValue), _next(next)
{}
};
Node* _top;
public:
Stack(): _top(NULL) {}
~Stack() { destroyStack(); }
bool isEmpty() const;
void push(int value);
int pop();
int getMin() const;
void destroyStack();
};
int main() {
Stack myStack;
myStack.push(3);
myStack.push(8);
myStack.push(2);
myStack.push(7);
myStack.push(11);
myStack.push(1);
myStack.push(2);
myStack.push(5);
myStack.push(10);
myStack.push(9);
int num = 0;
while (!myStack.isEmpty()) {
cout << "min:"<< myStack.getMin() << " ";
cout << myStack.pop() << endl;
}
cout << "\n";
cin.get();
return 0;
}
bool Stack::isEmpty() const {
if (_top == NULL)
return true;
else
return false;
}
void Stack::push(int value) {
if (isEmpty())
_top = new Node(value, value, _top);
else if (value <= _top->_minValue)
_top = new Node(value, value, _top);
else
_top = new Node(value, _top->_minValue, _top);
}
int Stack::pop() {
int num;
if (isEmpty())
cout << "\n\nstack is empty\n\n";
else {
num = _top->_value;
Node* temp = _top;
_top = _top->_next;
delete temp;
}
return num;
}
int Stack::getMin() const {
if (isEmpty())
cout << "\n\nstack is empty\n\n";
else
return _top->_minValue;
}
void Stack::destroyStack() {
while (_top != NULL) {
Node* temp = _top;
_top = _top->_next;
delete temp;
}
} | [
"[email protected]"
] | |
e4e59617930f0d942f9ac1c2fc566501070cd5b7 | 68dcf585fc0b1d31254d25d5cf51aae503310d81 | /Backtracking/sudoku.cpp | 9bf497643f12833135cc7dcc28b151774eca0b3c | [] | no_license | Sarthakdtu/C-Codes | 0a45b7b4e8fb6f7e85d0be56d0289e231850621a | 02da5037f165c962dfd3ceee660ff80ab36059a8 | refs/heads/master | 2020-06-16T06:33:09.267452 | 2020-02-01T16:24:35 | 2020-02-01T16:24:35 | 195,502,879 | 1 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 3,430 | cpp | #include<iostream>
using namespace std;
//sarthak
void display(int board[][9])
{
for(int i=0;i<9;i++)
{
for(int j=0;j<9;j++)
{
cout<<board[i][j]<<" ";
}
cout<<endl;
}
cout<<endl;
}
bool is3by3(int board[][9], int row1, int col1)
{
int row, col, limr, limc;
if(row1<3)
{
row = 0;
limr =3;
}
else if(row1<6)
{
row = 3;
limr =6;
}
else if(row1<9)
{
row = 6;
limr = 9;
}
if(col1<3)
{
col = 0;
limc =3;
}
else if(col1<6)
{
col = 3;
limc =6;
}
else if(col1<9)
{
col = 6;
limc = 9;
}
bool *check = new bool[10]();
for(int i = row;i<limr;i++)
{
for(int j = col;j<limc;j++)
{
if(check[board[i][j]] && board[i][j]!=0)
{
cout<<"I failed at "<<i<<" , "<<j<<" coz of "<<board[i][j]<<endl;
return false;
}
check[board[i][j]] = true;
}
}
return true;
}
bool isRow(int board[][9], int r)
{
//row wise
int *check = new int[10];
for(int i=0;i<9;i++)
{
if(board[r][i]==0||check[board[r][i]]==1)
return false;
check[board[r][i]]=1;
}
return true;
}
bool isCol(int board[][9], int c)
{
//row wise
for(int i=0;i<9;i++)
{
if(board[i][c]==0)
return false;
}
return true;
}
bool canBePlaced(int board[][9], int x, int y, int a)
{
for(int i=0;i<9;i++)
{
if(board[x][i]==a)
return false;
if(board[i][y]==a)
return false;
}
return true;
}
bool solve(int board[][9], int i, int j, bool **visited)
{
if(i==9)
{
cout<<"i = "<<9<<endl;
return true;
}
display(board);
//cout<<"i,j "<<i<<" , "<<j<<endl;
for(int y=j;y<9;y++)
{
// cout<<"i,y "<<i<<" , "<<y<<" value is "<<board[i][y]<<endl;
if(board[i][y]==0)
{
for(int a=1;a<10;a++)
{
if(canBePlaced(board, i, y, a))
{
cout<<"Trying to fill "<<i<<" , "<<y<<" with a = "<<a<<endl;
board[i][y] = a;
if(is3by3(board, i, y))
{
bool path = solve(board, i, y+1, visited);
if(path)
{
return true;
}
if(!path)
{
board[i][y]=0;
}
}
else
{
board[i][y]=0;
}
}
//cout<<"Sorry can't be placed"<<endl;
}
if(board[i][y]==0)
{
return false;
}
}
//cout<<"i,y "<<i<<" , "<<y<<"Here I am "<<endl;
//cout<<"Now going to i,y "<<i<<" , "<<y+1<<endl;
}
if(isRow(board, i))
{
return solve(board, i+1, 0, visited);
}
// board[j][y] =0;
return false;
}
bool sudokuSolver(int board[][9]){
/* Don't write main().
* Don't read input, it is passed as function argument.
* Don't print output and return output as specified in the question
*/
bool **visited = new bool*[9];
for(int i=0;i<9;i++)
{
visited[i] = new bool[9]();
}
return solve(board, 0, 0, visited);
}
int main()
{
int board[][9] = {
{9, 0, 0, 0 ,2 ,0, 7, 5, 0 },
{6 ,0, 0, 0 ,5, 0 ,0, 4, 0 },
{0 ,2 ,0 ,4 ,0 ,0, 0 ,1, 0 },
{2 ,0, 8, 0, 0 ,0, 0, 0, 0 },
{0 ,7 ,0 ,5 ,0, 9, 0 ,6 ,0} ,
{0, 0, 0, 0 ,0, 0, 4 ,0, 1 },
{0 ,1 ,0 ,0, 0 ,5 ,0, 8 ,0 },
{0, 9, 0, 0 ,7, 0, 0, 0, 4 },
{0 ,8 ,2 ,0 ,4, 0 ,0 ,0 ,6}
};
cout<<sudokuSolver(board)<<endl;
display(board);
return 0;
}
| [
"[email protected]"
] | |
18753fb612b8845c1ce8c3351aa2ac5e721cbf6a | 3b4db29ebde79579801d8952e8c84d4fcefb81bc | /RenderUtility/Vectors.h | 03335a4f5ed3410945e180881c50895a789a649f | [] | no_license | shusenl/simple-glsl-raycaster | beeb5f2b679e89733e3aa7c6050e4a0469ae9ca3 | b35ec4317b43924f0f861d0fe8e186224db3c485 | refs/heads/master | 2021-03-12T21:19:48.424678 | 2015-10-06T05:37:44 | 2015-10-06T05:37:44 | 43,574,771 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 66,394 | h | /*
For more information, please see: http://software.sci.utah.edu
The MIT License
Copyright (c) 2008 Scientific Computing and Imaging Institute,
University of Utah.
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.
*/
/**
\file Vectors.h
\brief Vector, matrix, and quaternion templates with additional OpenGL and Direct3D features
\author Jens Krueger
SCI Institute
University of Utah
\version 3.0
\date December 2008
*/
#pragma once
#ifndef VECTORS_H
#define VECTORS_H
#if defined DIRECT3D_VERSION
#define USEDX
#endif
#if defined __GL_H__
#define USEGL
#endif
// some DX files define min/max but that interferes
// with the numeric_limits so undef them
#ifdef min
#undef min
#endif
#ifdef max
#undef max
#endif
// use MAX / MIN instead
#ifndef MAX
#define MAX(a,b) (((a) > (b)) ? (a) : (b))
#endif
#ifndef MIN
#define MIN(a,b) (((a) < (b)) ? (a) : (b))
#endif
#include <cassert>
#include <cmath>
#include <istream>
#include <iomanip>
#include <limits>
#include <vector>
#ifdef WIN32
#pragma warning( disable : 4995 ) // disable deprecated warning
#endif
#include <ostream>
#ifdef WIN32
#pragma warning( default : 4995 )
#endif
#ifdef WIN32
#pragma warning( disable : 4201 ) // Disable warning messages about nameless union
#ifdef USEDX
#pragma message(" [vectors.h] Using DX extensions.\n")
#endif
#ifdef USEGL
#pragma message(" [vectors.h] Using GL extensions.\n")
#endif
#endif
#include "StdDefines.h"
template <class T> class MATRIX2;
template <class T> class MATRIX3;
template <class T> class MATRIX4;
template <class T=int> class VECTOR2 {
public:
T x,y;
VECTOR2<T>(): x(0), y(0) {}
template <class S> explicit VECTOR2<T>( const std::vector<S>& v ) {
x = T(v.size()>0 ? v[0] : 0);
y = T(v.size()>1 ? v[1] : 0);
}
VECTOR2<T>(const VECTOR2<T> &other): x(other.x), y(other.y) {}
template <class S> explicit VECTOR2<T>(const VECTOR2<S> &other): x(T(other.x)), y(T(other.y)) {}
VECTOR2<T>(const T _x, const T _y) : x(_x), y(_y) {}
VECTOR2<T>(const T* vec) : x(vec[0]), y(vec[1]) {}
bool operator == ( const VECTOR2<T>& other ) const {return (other.x==x && other.y==y); }
bool operator != ( const VECTOR2<T>& other ) const {return (other.x!=x || other.y!=y); }
// binary operators with scalars
VECTOR2<T> operator + ( T scalar ) const {return VECTOR2<T>(x+scalar,y+scalar);}
VECTOR2<T> operator - ( T scalar ) const {return VECTOR2<T>(x-scalar,y-scalar);}
VECTOR2<T> operator * ( T scalar ) const {return VECTOR2<T>(x*scalar,y*scalar);}
VECTOR2<T> operator / ( T scalar ) const {return VECTOR2<T>(x/scalar,y/scalar);}
VECTOR2<T> operator % ( T scalar ) const {return VECTOR2<T>(x%scalar,y%scalar);}
// binary operators with vectors
VECTOR2<T> operator + ( const VECTOR2& other ) const {return VECTOR2<T>(x+other.x,y+other.y);}
VECTOR2<T> operator - ( const VECTOR2& other ) const {return VECTOR2<T>(x-other.x,y-other.y);}
VECTOR2<T> operator / ( const VECTOR2& other ) const {return VECTOR2<T>(x/other.x,y/other.y);}
VECTOR2<T> operator * ( const VECTOR2& other ) const {return VECTOR2<T>(x*other.x,y*other.y);} // component product
T operator ^ ( const VECTOR2<T>& other ) const {return T(x*other.x+y*other.y);} // dot product
// unary operators
VECTOR2<T> operator + () const {return *this;}
VECTOR2<T> operator - () const {return *this * -1;}
VECTOR2<T> operator ~ () const {return VECTOR2<T>(T(1)/x,T(1)/y);}
// binary operators with a matrix
VECTOR2<T> operator * ( const MATRIX2<T>& matrix ) const {
return VECTOR2<T>(x*matrix.m11+y*matrix.m21,
x*matrix.m12+y*matrix.m22);
}
VECTOR2<T>& operator=(const VECTOR2<T>& other) { x = other.x; y = other.y;return *this; }
VECTOR2<T>& operator+=(const VECTOR2<T>& other) { x += other.x; y += other.y;return *this; }
VECTOR2<T>& operator-=(const VECTOR2<T>& other) { x -= other.x; y -= other.y;return *this; }
VECTOR2<T>& operator*=(const VECTOR2<T>& other) { x *= other.x; y *= other.y;return *this; }
VECTOR2<T>& operator/=(const VECTOR2<T>& other) { x /= other.x; y /= other.y;return *this; }
VECTOR2<T>& operator=(const T& other) { x = other; y = other;return *this; }
VECTOR2<T>& operator+=(const T& other) { x += other; y += other;return *this; }
VECTOR2<T>& operator-=(const T& other) { x -= other; y -= other;return *this; }
VECTOR2<T>& operator*=(const T& other) { x *= other; y *= other;return *this; }
VECTOR2<T>& operator/=(const T& other) { x /= other; y /= other;return *this; }
friend std::ostream& operator<<(std::ostream &os,const VECTOR2<T>& v){os << v.x << '\t' << v.y; return os;}
T& operator [](size_t i) {
assert(i <= 1);
return (i == 0) ? this->x : this->y;
}
const T& operator [](size_t i) const {
assert(i <= 1);
return (i == 0) ? this->x : this->y;
}
VECTOR2<T> abs() const {return VECTOR2<T>(fabs(x),fabs(y));}
T area() const {return x*y;}
T length() const {return sqrt(T(x*x+y*y));}
void normalize() {T len = length(); x/=len;y/=len;}
T maxVal() const {return MAX(x,y);}
T minVal() const {return MIN(x,y);}
VECTOR2<T> makepow2() const {
VECTOR2<T> vOut;
vOut.x = T(1<<int(ceil(log(double(x))/log(2.0))));
vOut.y = T(1<<int(ceil(log(double(y))/log(2.0))));
return vOut;
}
void StoreMin(const VECTOR2<T> &other) {
x = std::min(x,other.x);
y = std::min(y,other.y);
}
void StoreMax(const VECTOR2<T> &other) {
x = std::max(x,other.x);
y = std::max(y,other.y);
}
#ifdef USEDX
VECTOR2<T>(const D3DXVECTOR2 &other): x(T(other.x)), y(T(other.y)) {}
D3DXVECTOR2 toD3DXVEC() const {return D3DXVECTOR2(float(x),float(y));}
bool operator == ( const D3DXVECTOR2& other ) const {return (other.x==T(x) && other.y== T(y)); }
bool operator != ( const D3DXVECTOR2& other ) const {return (other.x!=T(x) || other.y!= T(y)); }
operator D3DXVECTOR2(void) const {return toD3DXVEC();}
#endif
// OpenGL
#ifdef USEGL
void glVertex() {
glVertex2f(GLfloat(x),GLfloat(y));
}
#endif
};
template <class T> VECTOR2<T> operator + ( T scalar, const VECTOR2<T>& vec ) {return VECTOR2<T>(scalar+vec.x,scalar+vec.y);}
template <class T> VECTOR2<T> operator - ( T scalar, const VECTOR2<T>& vec ) {return VECTOR2<T>(scalar-vec.x,scalar-vec.y);}
template <class T> VECTOR2<T> operator * ( T scalar, const VECTOR2<T>& vec ) {return VECTOR2<T>(scalar*vec.x,scalar*vec.y);}
template <class T> VECTOR2<T> operator / ( T scalar, const VECTOR2<T>& vec ) {return VECTOR2<T>(scalar/vec.x,scalar/vec.y);}
template <class T> VECTOR2<T> operator % ( T scalar, const VECTOR2<T>& vec ) {return VECTOR2<T>(scalar%vec.x,scalar%vec.y);}
template <class T>
std::istream& operator >>(std::istream &is, VECTOR2<T>& v2)
{
is >> v2[0];
is >> v2[1];
return is;
}
template <class T=int> class VECTOR3 {
public:
T x,y,z;
VECTOR3<T>(): x(0), y(0),z(0) {}
template <class S> explicit VECTOR3<T>( const std::vector<S>& v ) {
x = T(v.size()>0 ? v[0] : 0);
y = T(v.size()>1 ? v[1] : 0);
z = T(v.size()>2 ? v[2] : 0);
}
VECTOR3<T>(const VECTOR3<T> &other): x(other.x), y(other.y), z(other.z) {}
template <class S> explicit VECTOR3<T>(const VECTOR3<S> &other): x(T(other.x)), y(T(other.y)), z(T(other.z)) {}
VECTOR3<T>(const VECTOR2<T> &other, const T _z): x(other.x), y(other.y), z(_z) {}
VECTOR3<T>(const T _x, const T _y, const T _z) : x(_x), y(_y), z(_z) {}
VECTOR3<T>(const T* vec) : x(vec[0]), y(vec[1]), z(vec[2]) {}
bool operator == ( const VECTOR3<T>& other ) const {return (other.x==x && other.y==y && other.z==z); }
bool operator != ( const VECTOR3<T>& other ) const {return (other.x!=x || other.y!=y || other.z!=z); }
// binary operators with scalars
VECTOR3<T> operator + ( T scalar ) const {return VECTOR3<T>(x+scalar,y+scalar,z+scalar);}
VECTOR3<T> operator - ( T scalar ) const {return VECTOR3<T>(x-scalar,y-scalar,z-scalar);}
VECTOR3<T> operator * ( T scalar ) const {return VECTOR3<T>(x*scalar,y*scalar,z*scalar);}
VECTOR3<T> operator / ( T scalar ) const {return VECTOR3<T>(x/scalar,y/scalar,z/scalar);}
VECTOR3<T> operator % ( T scalar ) const {return VECTOR3<T>(x%scalar,y%scalar,z%scalar);}
// binary operators with vectors
VECTOR3<T> operator + ( const VECTOR3<T>& other ) const {return VECTOR3<T>(x+other.x,y+other.y,z+other.z);}
VECTOR3<T> operator - ( const VECTOR3<T>& other ) const {return VECTOR3<T>(x-other.x,y-other.y,z-other.z);}
VECTOR3<T> operator / ( const VECTOR3<T>& other ) const {return VECTOR3<T>(x/other.x,y/other.y,z/other.z);}
VECTOR3<T> operator * ( const VECTOR3<T>& other ) const {return VECTOR3<T>(x*other.x,y*other.y,z*other.z);} // component product
VECTOR3<T> operator % ( const VECTOR3<T>& other ) const {return VECTOR3<T>(y*other.z-z*other.y,z*other.x-x*other.z,x*other.y-y*other.x);} // cross product
T operator ^ ( const VECTOR3<T>& other ) const {return T(x*other.x+y*other.y+z*other.z);} // dot product
// unary opartors
VECTOR3<T> operator + () const {return *this;}
VECTOR3<T> operator - () const {return *this * -1;}
VECTOR3<T> operator ~ () const {return VECTOR3<T>(T(1)/x,T(1)/y,T(1)/z);}
// binary operators with a matrix
VECTOR3<T> operator * ( const MATRIX3<T>& matrix ) const {
return VECTOR3<T>(x*matrix.m11+y*matrix.m21+z*matrix.m31,
x*matrix.m12+y*matrix.m22+z*matrix.m32,
x*matrix.m13+y*matrix.m23+z*matrix.m33);
}
VECTOR3<T>& operator=(const VECTOR3<T>& other) { x = other.x; y = other.y; z = other.z; return *this; }
VECTOR3<T>& operator+=(const VECTOR3<T>& other) { x += other.x; y += other.y; z += other.z; return *this; }
VECTOR3<T>& operator-=(const VECTOR3<T>& other) { x -= other.x; y -= other.y; z -= other.z; return *this; }
VECTOR3<T>& operator*=(const VECTOR3<T>& other) { x *= other.x; y *= other.y; z *= other.z; return *this; }
VECTOR3<T>& operator/=(const VECTOR3<T>& other) { x /= other.x; y /= other.y; z /= other.z; return *this; }
VECTOR3<T>& operator=(const T& other) { x = other; y = other; z = other; return *this; }
VECTOR3<T>& operator+=(const T& other) { x += other; y += other; z += other; return *this; }
VECTOR3<T>& operator-=(const T& other) { x -= other; y -= other; z -= other; return *this; }
VECTOR3<T>& operator*=(const T& other) { x *= other; y *= other; z *= other; return *this; }
VECTOR3<T>& operator/=(const T& other) { x /= other; y /= other; z /= other; return *this; }
friend std::ostream& operator<<(std::ostream &os,const VECTOR3<T>& v){os << v.x << '\t' << v.y << '\t' << v.z; return os;}
T& operator [](size_t i) {
assert(i <= 2);
switch(i) {
case 0: return this->x;
case 1: return this->y;
default: return this->z;
}
}
const T& operator [](size_t i) const {
assert(i <= 2);
switch(i) {
case 0: return this->x;
case 1: return this->y;
default: return this->z;
}
}
VECTOR3<T> abs() const {return VECTOR3<T>(fabs(x),fabs(y),fabs(z));}
T maxVal() const {return MAX(x,MAX(y,z));}
T minVal() const {return MIN(x,MIN(y,z));}
T volume() const {return x*y*z;}
T length() const {return sqrt(T(x*x+y*y+z*z));}
void normalize() {T len = length(); x/=len;y/=len;z/=len;}
void normalize(T epsilon, const VECTOR3<T> replacement=VECTOR3<T>(T(0),T(0),T(1))) {
T len = length();
if (len > epsilon) {
x/=len;
y/=len;
z/=len;
} else { // specify some arbitrary normal
x = replacement.x;
y = replacement.y;
z = replacement.z;
}
}
VECTOR2<T> xx() const {return VECTOR2<T>(x,x);}
VECTOR2<T> xy() const {return VECTOR2<T>(x,y);}
VECTOR2<T> xz() const {return VECTOR2<T>(x,z);}
VECTOR2<T> yx() const {return VECTOR2<T>(y,x);}
VECTOR2<T> yy() const {return VECTOR2<T>(y,y);}
VECTOR2<T> yz() const {return VECTOR2<T>(y,z);}
VECTOR2<T> zx() const {return VECTOR2<T>(z,x);}
VECTOR2<T> zy() const {return VECTOR2<T>(z,y);}
VECTOR2<T> zz() const {return VECTOR2<T>(z,z);}
VECTOR3<T> makepow2() const {
VECTOR3<T> vOut;
vOut.x = T(1<<int(ceil(log(double(x))/log(2.0))));
vOut.y = T(1<<int(ceil(log(double(y))/log(2.0))));
vOut.z = T(1<<int(ceil(log(double(z))/log(2.0))));
return vOut;
}
void StoreMin(const VECTOR3<T> &other) {
x = std::min(x,other.x);
y = std::min(y,other.y);
z = std::min(z,other.z);
}
void StoreMax(const VECTOR3<T> &other) {
x = std::max(x,other.x);
y = std::max(y,other.y);
z = std::max(z,other.z);
}
#ifdef USEDX
VECTOR3(const D3DXVECTOR3 &other): x(T(other.x)), y(T(other.y)), z(T(other.z)) {}
VECTOR3(const D3DXVECTOR4 &other): x(T(other.x)), y(T(other.y)), z(T(other.z)) {}
D3DXVECTOR3 toD3DXVEC() const {return D3DXVECTOR3(float(x),float(y),float(z));}
bool operator == ( const D3DXVECTOR3& other ) const {return (other.x==T(x) && other.y== T(y) && other.z== T(z)); }
bool operator != ( const D3DXVECTOR3& other ) const {return (other.x!=T(x) || other.y!= T(y) || other.z!= T(z)); }
operator D3DXVECTOR3(void) const {return toD3DXVEC();}
#endif
// OpenGL
#ifdef USEGL
void glVertex() {
glVertex3f(GLfloat(x),GLfloat(y),GLfloat(z));
}
void glNormal() {
glNormal3f(GLfloat(x),GLfloat(y),GLfloat(z));
}
void glNNormal() {
normalize();
glNormal3f(GLfloat(x),GLfloat(y),GLfloat(z));
}
#endif
};
template <class T> VECTOR3<T> operator + ( T scalar, const VECTOR3<T>& vec ) {return VECTOR3<T>(scalar+vec.x,scalar+vec.y,scalar+vec.z);}
template <class T> VECTOR3<T> operator - ( T scalar, const VECTOR3<T>& vec ) {return VECTOR3<T>(scalar-vec.x,scalar-vec.y,scalar-vec.z);}
template <class T> VECTOR3<T> operator * ( T scalar, const VECTOR3<T>& vec ) {return VECTOR3<T>(scalar*vec.x,scalar*vec.y,scalar*vec.z);}
template <class T> VECTOR3<T> operator / ( T scalar, const VECTOR3<T>& vec ) {return VECTOR3<T>(scalar/vec.x,scalar/vec.y,scalar/vec.z);}
template <class T> VECTOR3<T> operator % ( T scalar, const VECTOR3<T>& vec ) {return VECTOR3<T>(scalar%vec.x,scalar%vec.y,scalar%vec.z);}
template <class T>
std::istream& operator >>(std::istream &is, VECTOR3<T>& v3)
{
is >> v3[0];
is >> v3[1];
is >> v3[2];
return is;
}
template <class T=int> class VECTOR4 {
template <class U>
friend std::istream& operator >>(std::istream &, VECTOR4<U>&);
public:
T x,y,z,w;
VECTOR4<T>(): x(0), y(0),z(0), w(0) {}
template <class S> explicit VECTOR4<T>( const std::vector<S>& v ) {
x = T(v.size()>0 ? v[0] : 0);
y = T(v.size()>1 ? v[1] : 0);
z = T(v.size()>2 ? v[2] : 0);
w = T(v.size()>3 ? v[3] : 0);
}
VECTOR4<T>(const VECTOR2<T> &other, const T _z, const T _w): x(other.x), y(other.y), z(_z), w(_w) {}
VECTOR4<T>(const VECTOR3<T> &other, const T _w): x(other.x), y(other.y), z(other.z), w(_w) {}
VECTOR4<T>(const VECTOR4<T> &other): x(other.x), y(other.y), z(other.z), w(other.w) {}
template <class S> explicit VECTOR4<T>(const VECTOR4<S> &other): x(T(other.x)), y(T(other.y)), z(T(other.z)), w(T(other.w)) {}
VECTOR4<T>(const VECTOR3<T> &other): x(other.x), y(other.y), z(other.z), w(1) {}
VECTOR4<T>(const T _x, const T _y, const T _z, const T _w) : x(_x), y(_y), z(_z), w(_w) {}
VECTOR4<T>(const T* vec) : x(vec[0]), y(vec[1]), z(vec[2]), w(vec[3]) {}
bool operator == ( const VECTOR4<T>& other ) const {return (other.x==x && other.y==y && other.z==z && other.w==w); }
bool operator != ( const VECTOR4<T>& other ) const {return (other.x!=x || other.y!=y || other.z!=z || other.w!=w); }
// binary operators with scalars
VECTOR4<T> operator + ( T scalar ) const {return VECTOR4<T>(x+scalar,y+scalar,z+scalar,w+scalar);}
VECTOR4<T> operator - ( T scalar ) const {return VECTOR4<T>(x-scalar,y-scalar,z-scalar,w-scalar);}
VECTOR4<T> operator * ( T scalar ) const {return VECTOR4<T>(x*scalar,y*scalar,z*scalar,w*scalar);}
VECTOR4<T> operator / ( T scalar ) const {return VECTOR4<T>(x/scalar,y/scalar,z/scalar,w/scalar);}
VECTOR4<T> operator % ( T scalar ) const {return VECTOR4<T>(x%scalar,y%scalar,z%scalar,w%scalar);}
// binary operators with vectors
VECTOR4<T> operator + ( const VECTOR4<T>& other ) const {return VECTOR4<T>(x+other.x,y+other.y,z+other.z,w+other.w);}
VECTOR4<T> operator - ( const VECTOR4<T>& other ) const {return VECTOR4<T>(x-other.x,y-other.y,z-other.z,w-other.w);}
VECTOR4<T> operator * ( const VECTOR4<T>& other ) const {return VECTOR4<T>(x*other.x,y*other.y,z*other.z,w*other.w);}
VECTOR4<T> operator / ( const VECTOR4<T>& other ) const {return VECTOR4<T>(x/other.x,y/other.y,z/other.z,w/other.w);}
T operator ^ ( const VECTOR4<T>& other ) const {return T(x*other.x+y*other.y+z*other.z+w*other.w);} // dot product
// binary operators with a matrix
VECTOR4<T> operator * ( const MATRIX4<T>& matrix ) const {
return VECTOR4<T>(x*matrix.m11+y*matrix.m21+z*matrix.m31+w*matrix.m41,
x*matrix.m12+y*matrix.m22+z*matrix.m32+w*matrix.m42,
x*matrix.m13+y*matrix.m23+z*matrix.m33+w*matrix.m43,
x*matrix.m14+y*matrix.m24+z*matrix.m34+w*matrix.m44);
}
// unary opartors
VECTOR4<T> operator + () const {return *this;}
VECTOR4<T> operator - () const {return *this * -1;}
VECTOR4<T> operator ~ () const {return VECTOR4<T>(T(1)/x,T(1)/y,T(1)/z,T(1)/w);}
T& operator [](size_t i) {
assert(i <= 3);
switch(i) {
case 0: return this->x;
case 1: return this->y;
case 2: return this->z;
default: return this->w;
}
}
const T& operator [](size_t i) const {
assert(i <= 3);
switch(i) {
case 0: return this->x;
case 1: return this->y;
case 2: return this->z;
default: return this->w;
}
}
VECTOR4<T>& operator=(const VECTOR4<T>& other) { x = other.x; y = other.y; z = other.z; w = other.w; return *this; }
VECTOR4<T>& operator+=(const VECTOR4<T>& other) { x += other.x; y += other.y; z += other.z; w += other.w; return *this; }
VECTOR4<T>& operator-=(const VECTOR4<T>& other) { x -= other.x; y -= other.y; z -= other.z; w -= other.w; return *this; }
VECTOR4<T>& operator*=(const VECTOR4<T>& other) { x *= other.x; y *= other.y; z *= other.z; w *= other.w; return *this; }
VECTOR4<T>& operator/=(const VECTOR4<T>& other) { x /= other.x; y /= other.y; z /= other.z; w /= other.w; return *this; }
VECTOR4<T>& operator=(const T& other) { x = other; y = other; z = other; w = other; return *this; }
VECTOR4<T>& operator+=(const T& other) { x += other; y += other; z += other; w += other; return *this; }
VECTOR4<T>& operator-=(const T& other) { x -= other; y -= other; z -= other; w -= other; return *this; }
VECTOR4<T>& operator*=(const T& other) { x *= other; y *= other; z *= other; w *= other; return *this; }
VECTOR4<T>& operator/=(const T& other) { x /= other; y /= other; z /= other; w /= other; return *this; }
friend std::ostream& operator<<(std::ostream &os,const VECTOR4<T>& v) {
/*os << "[" << std::setiosflags(std::ios::left)
<< std::setw(7) << std::setprecision(3) << v.x
<< std::resetiosflags(std::ios::left)
<< std::setw(7) << std::setprecision(3) << v.y
<< std::setw(7) << std::setprecision(3) << v.z
<< std::setw(7) << std::setprecision(3) << v.w
<< "]";
*/
os << v.x << '\t' << v.y << '\t' << v.z<< '\t' << v.w;
return os;
}
T max() const {return MAX(MAX(x,y),MAX(z,w));}
T min() const {return MIN(MIN(x,y),MIN(z,w));}
VECTOR4<T> abs() const {return VECTOR4<T>(fabs(x),fabs(y),fabs(z),fabs(w));}
VECTOR4<T> makepow2() const {
VECTOR4<T> vOut;
vOut.x = T(1<<int(ceil(log(double(x))/log(2.0))));
vOut.y = T(1<<int(ceil(log(double(y))/log(2.0))));
vOut.z = T(1<<int(ceil(log(double(z))/log(2.0))));
vOut.w = T(1<<int(ceil(log(double(w))/log(2.0))));
return vOut;
}
VECTOR3<T> dehomo() const {
VECTOR3<T> vOut;
vOut.x = x/w;
vOut.y = y/w;
vOut.z = z/w;
return vOut;
}
void StoreMin(const VECTOR4<T> &other) {
x = std::min(x,other.x);
y = std::min(y,other.y);
z = std::min(z,other.z);
w = std::min(w,other.w);
}
void StoreMax(const VECTOR4<T> &other) {
x = std::max(x,other.x);
y = std::max(y,other.y);
z = std::max(z,other.z);
w = std::max(w,other.w);
}
VECTOR2<T> xx() const {return VECTOR2<T>(x,x);}
VECTOR2<T> xy() const {return VECTOR2<T>(x,y);}
VECTOR2<T> xz() const {return VECTOR2<T>(x,z);}
VECTOR2<T> yx() const {return VECTOR2<T>(y,x);}
VECTOR2<T> yy() const {return VECTOR2<T>(y,y);}
VECTOR2<T> yz() const {return VECTOR2<T>(y,z);}
VECTOR2<T> zx() const {return VECTOR2<T>(z,x);}
VECTOR2<T> zy() const {return VECTOR2<T>(z,y);}
VECTOR2<T> zz() const {return VECTOR2<T>(z,z);}
VECTOR2<T> zw() const {return VECTOR2<T>(z,w);}
VECTOR3<T> xyz() const {return VECTOR3<T>(x,y,z);}
// DirectX
#ifdef USEDX
VECTOR4<T>(const D3DXVECTOR4 &other): x(T(other.x)), y(T(other.y)), z(T(other.z)), w(T(other.w)){}
D3DXVECTOR4 toD3DXVEC() const {return D3DXVECTOR4(float(x),float(y),float(z),float(w));}
bool operator == ( const D3DXVECTOR4& other ) const {return (other.x==T(x) && other.y==T(y) && other.z==T(z) && other.w==T(w)); }
bool operator != ( const D3DXVECTOR4& other ) const {return (other.x!=T(x) || other.y!=T(y) || other.z!=T(z) || other.w!=T(w)); }
operator D3DXVECTOR4(void) const {return toD3DXVEC();}
#endif
// OpenGL
#ifdef USEGL
void glVertex() {
glVertex4f(GLfloat(x),GLfloat(y),GLfloat(z),GLfloat(w));
}
void glNormal() {
dehomo().glNormal();
}
#endif
};
template <class T>
std::istream& operator >>(std::istream &is, VECTOR4<T>& v4)
{
is >> v4[0];
is >> v4[1];
is >> v4[2];
is >> v4[3];
return is;
}
template <class T> VECTOR4<T> operator + ( T scalar, const VECTOR4<T>& vec ) {return VECTOR4<T>(scalar+vec.x,scalar+vec.y,scalar+vec.z,scalar+vec.w);}
template <class T> VECTOR4<T> operator - ( T scalar, const VECTOR4<T>& vec ) {return VECTOR4<T>(scalar-vec.x,scalar-vec.y,scalar-vec.z,scalar-vec.w);}
template <class T> VECTOR4<T> operator * ( T scalar, const VECTOR4<T>& vec ) {return VECTOR4<T>(scalar*vec.x,scalar*vec.y,scalar*vec.z,scalar*vec.w);}
template <class T> VECTOR4<T> operator / ( T scalar, const VECTOR4<T>& vec ) {return VECTOR4<T>(scalar/vec.x,scalar/vec.y,scalar/vec.z,scalar/vec.w);}
template <class T> VECTOR4<T> operator % ( T scalar, const VECTOR4<T>& vec ) {return VECTOR4<T>(scalar%vec.x,scalar%vec.y,scalar%vec.z,scalar%vec.w);}
typedef VECTOR4<> INTVECTOR4;
typedef VECTOR3<> INTVECTOR3;
typedef VECTOR2<> INTVECTOR2;
typedef VECTOR4<UINT32> UINTVECTOR4;
typedef VECTOR3<UINT32> UINTVECTOR3;
typedef VECTOR2<UINT32> UINTVECTOR2;
typedef VECTOR3<UINT64> UINT64VECTOR3;
typedef VECTOR4<unsigned char> UCHARVECTOR4;
typedef VECTOR3<unsigned char> UCHARVECTOR3;
typedef VECTOR2<unsigned char> UCHARVECTOR2;
typedef VECTOR4<unsigned short> USHORTVECTOR4;
typedef VECTOR3<unsigned short> USHORTVECTOR3;
typedef VECTOR2<unsigned short> USHORTVECTOR2;
typedef VECTOR4<float> FLOATVECTOR4;
typedef VECTOR3<float> FLOATVECTOR3;
typedef VECTOR2<float> FLOATVECTOR2;
typedef VECTOR4<double> DOUBLEVECTOR4;
typedef VECTOR3<double> DOUBLEVECTOR3;
typedef VECTOR2<double> DOUBLEVECTOR2;
template <class T=int> class MATRIX2 {
public:
union {
struct {
T m11,m12,
m21,m22;
};
T array[4];
};
MATRIX2() : m11(1), m12(0),
m21(0), m22(1) {};
MATRIX2( const T *e ) : m11(e[0]), m12(e[1]),
m21(e[4]), m22(e[5]) {};
MATRIX2( const MATRIX2<T>& other ) : m11(other.m11), m12(other.m12),
m21(other.m21), m22(other.m22) {};
MATRIX2( const MATRIX3<T>& other ) : m11(other.m11), m12(other.m12),
m21(other.m21), m22(other.m22) {};
MATRIX2( const MATRIX4<T>& other ) : m11(other.m11), m12(other.m12),
m21(other.m21), m22(other.m22) {};
MATRIX2( const VECTOR2<T> *rows ) : m11(rows[0].x), m12(rows[0].y),
m21(rows[1].x), m22(rows[1].y) {};
MATRIX2(T _m11, T _m12, T _m21, T _m22) : m11(_m11), m12(_m12),
m21(_m21), m22(_m22) {};
bool operator == ( const MATRIX2<T>& other ) const {return (other.m11==m11 && other.m12==m12 && other.m21==m21 && other.m22==m22); }
bool operator != ( const MATRIX2<T>& other ) const {return (other.m11!=m11 || other.m12!=m12 || other.m21!=m21 || other.m22!=m22); }
friend std::ostream& operator<<(std::ostream &os,const MATRIX2<T>& m){os << m.m11 << '\t' << m.m12 << '\n' << m.m21 << '\t' << m.m22; return os;}
// binary operators with scalars
MATRIX2<T> operator * ( T scalar ) const {return MATRIX2<T>(m11*scalar,m12*scalar,
m21*scalar,m22*scalar);}
MATRIX2<T> operator + ( T scalar ) const {return MATRIX2<T>(m11+scalar,m12+scalar,
m21+scalar,m22+scalar);}
MATRIX2<T> operator - ( T scalar ) const {return MATRIX2<T>(m11-scalar,m12-scalar,
m21-scalar,m22-scalar);}
MATRIX2<T> operator / ( T scalar ) const {return MATRIX2<T>(m11/scalar,m12/scalar,
m21/scalar,m22/scalar);}
// binary operators with matrices
MATRIX2<T> operator * ( const MATRIX4<T>& other ) const {
MATRIX2<T> result;
for (int x = 0;x<4;x+=2)
for (int y = 0;y<2;y++)
result[x+y] = array[0+x]*other.array[0+y] + array[1+x]*other.array[2+y];
return result;
}
// binary operators with vectors
VECTOR2<T> operator * ( const VECTOR2<T>& other ) const {
return VECTOR2<T>(other.x*m11+other.y*m12,
other.x*m22+other.y*m22);
}
MATRIX2<T> inverse() const {
T determinant = m11*m22-m12*m21;
return MATRIX2<T> (m22/determinant, -m12/determinant,-m21/determinant, m11/determinant);
}
};
template <class T> class MATRIX3 {
public:
union {
struct {
T m11,m12,m13,
m21,m22,m23,
m31,m32,m33;
};
T array[9];
};
MATRIX3() : m11(1), m12(0), m13(0),
m21(0), m22(1), m23(0),
m31(0), m32(0), m33(1) {};
MATRIX3( const T *e ) : m11(e[0]), m12(e[1]), m13(e[2]),
m21(e[3]), m22(e[4]), m23(e[5]),
m31(e[6]), m32(e[7]), m33(e[8]) {};
MATRIX3( const MATRIX3<T>& other ) : m11(other.m11), m12(other.m12), m13(other.m13),
m21(other.m21), m22(other.m22), m23(other.m23),
m31(other.m31), m32(other.m32), m33(other.m33) {};
MATRIX3( const MATRIX4<T>& other ) : m11(other.m11), m12(other.m12), m13(other.m13),
m21(other.m21), m22(other.m22), m23(other.m23),
m31(other.m31), m32(other.m32), m33(other.m33) {};
MATRIX3( const VECTOR3<T> *rows ) : m11(rows[0].x), m12(rows[0].y), m13(rows[0].z),
m21(rows[1].x), m22(rows[1].y), m23(rows[1].z),
m31(rows[2].x), m32(rows[2].y), m33(rows[2].z) {};
MATRIX3(T _m11, T _m12, T _m13,
T _m21, T _m22, T _m23,
T _m31, T _m32, T _m33) : m11(_m11), m12(_m12), m13(_m13),
m21(_m21), m22(_m22), m23(_m23),
m31(_m31), m32(_m32), m33(_m33) {};
bool operator == ( const MATRIX3<T>& other ) const {return (other.m11==m11 && other.m12==m12 && other.m13==m13 &&
other.m21==m21 && other.m22==m22 && other.m23==m23 &&
other.m31==m31 && other.m32==m32 && other.m33==m33); }
bool operator != ( const MATRIX3<T>& other ) const {return (other.m11!=m11 || other.m12!=m12 || other.m13!=m13 ||
other.m21!=m21 || other.m22!=m22 || other.m23!=m23 ||
other.m31!=m31 || other.m32!=m32 || other.m33!=m33); }
friend std::ostream& operator<<(std::ostream &os,const MATRIX3<T>& m){os << m.m11 << '\t' << m.m12 << '\t' << m.m13 << '\n'
<< m.m21 << '\t' << m.m22 << '\t' << m.m23 << '\n'
<< m.m31 << '\t' << m.m32 << '\t' << m.m33; return os;}
// binary operators with matrices
MATRIX3<T> operator * ( const MATRIX3<T>& other ) const {
MATRIX3<T> result;
for (int x = 0;x<9;x+=3)
for (int y = 0;y<3;y++)
result[x+y] = array[1+x] * other.array[0+y]+
array[2+x] * other.array[3+y]+
array[3+x] * other.array[6+y];
return result;
}
// binary operators with scalars
MATRIX3<T> operator * ( T scalar ) const {return MATRIX3<T>(m11*scalar,m12*scalar,m13*scalar,
m21*scalar,m22*scalar,m23*scalar,
m31*scalar,m32*scalar,m33*scalar);}
MATRIX3<T> operator + ( T scalar ) const {return MATRIX3<T>(m11+scalar,m12+scalar,m13+scalar,
m21+scalar,m22+scalar,m23+scalar,
m31+scalar,m32+scalar,m33+scalar);}
MATRIX3<T> operator - ( T scalar ) const {return MATRIX3<T>(m11-scalar,m12-scalar,m13-scalar,
m21-scalar,m22-scalar,m23-scalar,
m31-scalar,m32-scalar,m33-scalar);}
MATRIX3<T> operator / ( T scalar ) const {return MATRIX3<T>(m11/scalar,m12/scalar,m13/scalar,
m21/scalar,m22/scalar,m23/scalar,
m31/scalar,m32/scalar,m33/scalar);}
// binary operators with vectors
VECTOR3<T> operator * ( const VECTOR3<T>& other ) const {
return VECTOR3<T>(other.x*m11+other.y*m12+other.z*m13,
other.x*m21+other.y*m22+other.z*m23,
other.x*m31+other.y*m32+other.z*m33);
}
void Scaling(T x, T y, T z) {
m11=x; m12=0; m13=0;
m21=0; m22=y; m23=0;
m31=0; m32=0; m33=z;
}
void RotationX(double angle) {
T dCosAngle = T(cos(angle));
T dSinAngle = T(sin(angle));
m11=1; m12=0; m13=0;
m21=0; m22= dCosAngle; m23=dSinAngle;
m31=0; m32=-dSinAngle; m33=dCosAngle;
}
void RotationY(double angle) {
T dCosAngle = T(cos(angle));
T dSinAngle = T(sin(angle));
m11=dCosAngle; m12=0; m13=-dSinAngle;
m21=0; m22=1; m23=0;
m31=dSinAngle; m32=0; m33=dCosAngle;
}
void RotationZ(double angle) {
T dCosAngle = T(cos(angle));
T dSinAngle = T(sin(angle));
m11=dCosAngle; m12=dSinAngle; m13=0;
m21=-dSinAngle; m22=dCosAngle; m23=0;
m31=0; m32=0; m33=1;
}
void RotationAxis(const VECTOR3<T>& axis, double angle) {
T dCosAngle = T(cos(angle));
T dSinAngle = T(sin(angle));
T dOneMinusCosAngle = 1-dCosAngle;
VECTOR3<T> sqrAxis = axis * axis;
m11 = dCosAngle+dOneMinusCosAngle*sqrAxis.x; m12 = dOneMinusCosAngle*axis.x*axis.y-dSinAngle*axis.z; m13 = dOneMinusCosAngle*axis.x*axis.z+dSinAngle*axis.y;
m21 = dOneMinusCosAngle*axis.x*axis.y+dSinAngle*axis.z; m22 = dCosAngle+dOneMinusCosAngle*sqrAxis.y; m23 = dOneMinusCosAngle*axis.y*axis.z-dSinAngle*axis.x;
m31 = dOneMinusCosAngle*axis.x*axis.z-dSinAngle*axis.y; m32 = dOneMinusCosAngle*axis.y*axis.z+dSinAngle*axis.x; m33=dCosAngle+dOneMinusCosAngle*sqrAxis.z;
}
MATRIX3<T> inverse() const {
T determ = 1.0f/(array[0]*(array[4]*array[8]-array[5]*array[7]) - array[1]*(array[3]*array[8]-array[5]*array[6]) + array[2]*(array[3]*array[7]-array[4]*array[6]));
MATRIX3<T> result;
result.array[0]=determ*(array[4]*array[8]-array[5]*array[7]);
result.array[3]=determ*(array[2]*array[7]-array[1]*array[8]);
result.array[6]=determ*(array[1]*array[5]-array[2]*array[4]);
result.array[1]=determ*(array[5]*array[6]-array[3]*array[8]);
result.array[4]=determ*(array[0]*array[8]-array[2]*array[6]);
result.array[7]=determ*(array[2]*array[3]-array[0]*array[5]);
result.array[2]=determ*(array[3]*array[7]-array[4]*array[6]);
result.array[5]=determ*(array[1]*array[6]-array[0]*array[7]);
result.array[8]=determ*(array[0]*array[4]-array[1]*array[3]);
return result;
}
// DirectX
#ifdef USEDX
MATRIX3( const D3DXMATRIX& other ) : m11(other(0,0)), m12(other(0,1)), m13(other(0,2)),
m21(other(1,0)), m22(other(1,1)), m23(other(1,2)),
m31(other(2,0)), m32(other(2,1)), m33(other(2,2)) {};
D3DXMATRIX toD3DXMAT() const {return D3DXMATRIX(m11,m12,m13,0,m21,m22,m23,0,m31,m32,m33,0,0,0,0,1);}
operator D3DXMATRIX(void) const {return toD3DXMAT();}
#endif
// OpenGL
#ifdef USEGL
void getProjection() {
float P[16];
glGetFloatv(GL_PROJECTION_MATRIX,P);
m11 = T(P[0]); m12 = T(P[1]); m13 = T(P[2]);
m21 = T(P[4]); m22 = T(P[5]); m23 = T(P[6]);
m31 = T(P[8]); m32 = T(P[9]); m33 = T(P[10]);
}
void getModelview() {
float M[16];
glGetFloatv(GL_MODELVIEW_MATRIX,M);
m11 = T(M[0]); m12 = T(M[1]); m13 = T(M[2]);
m21 = T(M[4]); m22 = T(M[5]); m23 = T(M[6]);
m31 = T(M[8]); m32 = T(M[9]); m33 = T(M[10]);
}
void multModelview() const{
float M[16];
M[0] = float(m11); M[1] = float(m12); M[2] = float(m13); M[3] = 0;
M[4] = float(m21); M[5] = float(m22); M[6] = float(m23); M[7] = 0;
M[8] = float(m31); M[9] = float(m32); M[10] = float(m33); M[11] = 0;
M[12] = 0; M[13] = 0; M[14] = 0; M[15] =1;
glMatrixMode(GL_MODELVIEW);
glMultMatrixf(M);
}
void setModelview() const{
float M[16];
M[0] = float(m11); M[1] = float(m12); M[2] = float(m13); M[3] = 0;
M[4] = float(m21); M[5] = float(m22); M[6] = float(m23); M[7] = 0;
M[8] = float(m31); M[9] = float(m32); M[10] = float(m33); M[11] = 0;
M[12] = 0; M[13] = 0; M[14] = 0; M[15] =1;
glMatrixMode(GL_MODELVIEW);
glLoadMatrixf(M);
}
#endif
};
template <class T> class MATRIX4 {
template <class U>
friend std::istream& operator >>(std::istream &, MATRIX4<U>&);
public:
union {
struct {
T m11,m12,m13,m14,
m21,m22,m23,m24,
m31,m32,m33,m34,
m41,m42,m43,m44;
};
T array[16];
};
MATRIX4() : m11(1), m12(0), m13(0), m14(0),
m21(0), m22(1), m23(0), m24(0),
m31(0), m32(0), m33(1), m34(0),
m41(0), m42(0), m43(0), m44(1) {};
MATRIX4( const T *e ) : m11(e[0]), m12(e[1]), m13(e[2]), m14(e[3]),
m21(e[4]), m22(e[5]), m23(e[6]), m24(e[7]),
m31(e[8]), m32(e[9]), m33(e[10]), m34(e[11]),
m41(e[12]), m42(e[13]), m43(e[14]), m44(e[15]) {};
MATRIX4( const MATRIX4<T>& other ) : m11(other.m11), m12(other.m12), m13(other.m13), m14(other.m14),
m21(other.m21), m22(other.m22), m23(other.m23), m24(other.m24),
m31(other.m31), m32(other.m32), m33(other.m33), m34(other.m34),
m41(other.m41), m42(other.m42), m43(other.m43), m44(other.m44) {};
MATRIX4( const MATRIX3<T>& other ) : m11(other.m11), m12(other.m12), m13(other.m13), m14(0),
m21(other.m21), m22(other.m22), m23(other.m23), m24(0),
m31(other.m31), m32(other.m32), m33(other.m33), m34(0),
m41(0), m42(0), m43(0), m44(1) {};
MATRIX4( const VECTOR4<T> *rows ) : m11(rows[0].x), m12(rows[0].y), m13(rows[0].z), m14(rows[0].w),
m21(rows[1].x), m22(rows[1].y), m23(rows[1].z), m24(rows[1].w),
m31(rows[2].x), m32(rows[2].y), m33(rows[2].z), m34(rows[2].w),
m41(rows[3].x), m42(rows[3].y), m43(rows[3].z), m44(rows[3].w) {};
MATRIX4(T _m11, T _m12, T _m13, T _m14,
T _m21, T _m22, T _m23, T _m24,
T _m31, T _m32, T _m33, T _m34,
T _m41, T _m42, T _m43, T _m44) :
m11(_m11), m12(_m12), m13(_m13), m14(_m14),
m21(_m21), m22(_m22), m23(_m23), m24(_m24),
m31(_m31), m32(_m32), m33(_m33), m34(_m34),
m41(_m41), m42(_m42), m43(_m43), m44(_m44) {};
bool operator == ( const MATRIX4<T>& other ) const {return (other.m11==m11 && other.m12==m12 && other.m13==m13 && other.m14==m14 &&
other.m21==m21 && other.m22==m22 && other.m23==m23 && other.m24==m24 &&
other.m31==m31 && other.m32==m32 && other.m33==m33 && other.m34==m34 &&
other.m31==m41 && other.m32==m42 && other.m33==m43 && other.m44==m44); }
bool operator != ( const MATRIX4<T>& other ) const {return (other.m11!=m11 || other.m12!=m12 || other.m13!=m13 || other.m14!=m14 ||
other.m21!=m21 || other.m22!=m22 || other.m23!=m23 || other.m24!=m24 ||
other.m31!=m31 || other.m32!=m32 || other.m33!=m33 || other.m34!=m34 ||
other.m41!=m41 || other.m42!=m42 || other.m43!=m43 || other.m44!=m44); }
friend std::ostream& operator<<(std::ostream &os,const MATRIX4<T>& m){os << m.m11 << '\t' << m.m12 << '\t' << m.m13 << '\t' << m.m14 << '\n'
<< m.m21 << '\t' << m.m22 << '\t' << m.m23 << '\t' << m.m24 << '\n'
<< m.m31 << '\t' << m.m32 << '\t' << m.m33 << '\t' << m.m34 << '\n'
<< m.m41 << '\t' << m.m42 << '\t' << m.m43 << '\t' << m.m44 ; return os;}
operator T*(void) {return &m11;}
const T *operator *(void) const {return &m11;}
T *operator *(void) {return &m11;}
// binary operators with scalars
MATRIX4<T> operator * ( T scalar ) const {return MATRIX4<T>(m11*scalar,m12*scalar,m13*scalar,m14*scalar,
m21*scalar,m22*scalar,m23*scalar,m24*scalar,
m31*scalar,m32*scalar,m33*scalar,m34*scalar,
m41*scalar,m42*scalar,m43*scalar,m44*scalar);}
MATRIX4<T> operator + ( T scalar ) const {return MATRIX4<T>(m11+scalar,m12+scalar,m13+scalar,m14+scalar,
m21+scalar,m22+scalar,m23+scalar,m24+scalar,
m31+scalar,m32+scalar,m33+scalar,m34+scalar,
m41+scalar,m42+scalar,m43+scalar,m44+scalar);}
MATRIX4<T> operator - ( T scalar ) const {return MATRIX4<T>(m11-scalar,m12-scalar,m13-scalar,m14-scalar,
m21-scalar,m22-scalar,m23-scalar,m24-scalar,
m31-scalar,m32-scalar,m33-scalar,m34-scalar,
m41-scalar,m42-scalar,m43-scalar,m44-scalar);}
MATRIX4<T> operator / ( T scalar ) const {return MATRIX4<T>(m11/scalar,m12/scalar,m13/scalar,m14/scalar,
m21/scalar,m22/scalar,m23/scalar,m24/scalar,
m31/scalar,m32/scalar,m33/scalar,m34/scalar,
m41/scalar,m42/scalar,m43/scalar,m44/scalar);}
// binary operators with matrices
MATRIX4<T> operator * ( const MATRIX4<T>& other ) const {
MATRIX4<T> result;
for (int x = 0;x<16;x+=4)
for (int y = 0;y<4;y++)
result[x+y] = array[0+x] * other.array[0+y]+
array[1+x] * other.array[4+y]+
array[2+x] * other.array[8+y]+
array[3+x] * other.array[12+y];
return result;
}
// binary operators with vectors
VECTOR4<T> operator * ( const VECTOR4<T>& other ) const {
return VECTOR4<T>(other.x*m11+other.y*m12+other.z*m13+other.w*m14,
other.x*m21+other.y*m22+other.z*m23+other.w*m24,
other.x*m31+other.y*m32+other.z*m33+other.w*m34,
other.x*m41+other.y*m42+other.z*m43+other.w*m44);
}
VECTOR3<T> operator * ( const VECTOR3<T>& other ) const {
return VECTOR3<T>(other.x*m11+other.y*m12+other.z*m13,
other.x*m21+other.y*m22+other.z*m23,
other.x*m31+other.y*m32+other.z*m33);
}
void Translation(VECTOR3<T> trans) {
Translation(trans.x, trans.y, trans.z);
}
void Scaling(VECTOR3<T> scale) {
Scaling(scale.x, scale.y, scale.z);
}
void Translation(T x, T y, T z) {
m11=1; m12=0; m13=0; m14=0;
m21=0; m22=1; m23=0; m24=0;
m31=0; m32=0; m33=1; m34=0;
m41=x; m42=y; m43=z; m44=1;
}
void Scaling(T x, T y, T z) {
m11=x; m12=0; m13=0; m14=0;
m21=0; m22=y; m23=0; m24=0;
m31=0; m32=0; m33=z; m34=0;
m41=0; m42=0; m43=0; m44=1;
}
void RotationX(double angle) {
T dCosAngle = T(cos(angle));
T dSinAngle = T(sin(angle));
m11=1; m12=0; m13=0; m14=0;
m21=0; m22= dCosAngle; m23=dSinAngle; m24=0;
m31=0; m32=-dSinAngle; m33=dCosAngle; m34=0;
m41=0; m42=0; m43=0; m44=1;
}
void RotationY(double angle) {
T dCosAngle = T(cos(angle));
T dSinAngle = T(sin(angle));
m11=dCosAngle; m12=0; m13=-dSinAngle; m14=0;
m21=0; m22=1; m23=0; m24=0;
m31=dSinAngle; m32=0; m33=dCosAngle; m34=0;
m41=0; m42=0; m43=0; m44=1;
}
void RotationZ(double angle) {
T dCosAngle = T(cos(angle));
T dSinAngle = T(sin(angle));
m11=dCosAngle; m12=dSinAngle; m13=0;
m21=-dSinAngle; m22=dCosAngle; m23=0;
m31=0; m32=0; m33=1;
m41=0; m42=0; m43=0; m44=1;
}
void RotationAxis(const VECTOR3<T>& axis, double angle) {
T dCosAngle = T(cos(angle));
T dSinAngle = T(sin(angle));
T dOneMinusCosAngle = 1-dCosAngle;
VECTOR3<T> sqrAxis = axis * axis;
m11 = dCosAngle+dOneMinusCosAngle*sqrAxis.x; m12 = dOneMinusCosAngle*axis.x*axis.y-dSinAngle*axis.z; m13 = dOneMinusCosAngle*axis.x*axis.z+dSinAngle*axis.y; m14=0;
m21 = dOneMinusCosAngle*axis.x*axis.y+dSinAngle*axis.z; m22 = dCosAngle+dOneMinusCosAngle*sqrAxis.y; m23 = dOneMinusCosAngle*axis.y*axis.z-dSinAngle*axis.x; m24=0;
m31 = dOneMinusCosAngle*axis.x*axis.z-dSinAngle*axis.y; m32 = dOneMinusCosAngle*axis.y*axis.z+dSinAngle*axis.x; m33 = dCosAngle+dOneMinusCosAngle*sqrAxis.z; m34=0;
m41 = 0; m42 = 0; m43 = 0; m44=1;
}
MATRIX4<T> Transpose() const {
MATRIX4<T> result;
result.m41 = m14;
result.m31 = m13; result.m42 = m24;
result.m21 = m12; result.m32 = m23; result.m43 = m34;
result.m11 = m11; result.m22 = m22; result.m33 = m33; result.m44 = m44;
result.m12 = m21; result.m23 = m32; result.m34 = m43;
result.m13 = m31; result.m24 = m42;
result.m14 = m41;
return result;
}
MATRIX4<T> inverse() const {
MATRIX4<T> result;
T Q = m21 *(m34*( m12 * m43 - m13 * m42)+
m14 *(-m32 * m43 + m42 * m33)+
m44*( m13 * m32 - m12 * m33))
+
m24 *(m11 *( m32 * m43 - m42 * m33)+
m13 *(-m41* m32 + m31 * m42)+
m12 *(-m31 * m43 + m41 * m33))
+
m44*(m22 *(-m31 * m13 + m11 * m33)+
m23 *(-m11 * m32 + m12 * m31))
+
m34*(m11 *(-m22 * m43 + m23 * m42)+
m41*( m13 * m22 - m23 * m12))
+
m14* (m23 *( m32 * m41 - m42 * m31)+
m22 *( m31 * m43 - m41 * m33));
result.m11 = ( m24 * m32 * m43
+ m44 * m22 * m33
- m44 * m23 * m32
- m34 * m22 * m43
- m24 * m42 * m33
+ m34 * m23 * m42)/Q;
result.m21 = -( m21 * m44 * m33
- m21 * m34 * m43
- m44 * m23 * m31
+ m34 * m23 * m41
+ m24 * m31 * m43
- m24 * m41 * m33)/Q;
result.m31 = (- m21 * m34 * m42
+ m21 * m44 * m32
- m44 * m31 * m22
- m24 * m41 * m32
+ m34 * m41 * m22
+ m24 * m31 * m42)/Q;
result.m41 = -(m21 * m32 * m43
- m21 * m42 * m33
+ m41 * m22 * m33
- m32 * m23 * m41
- m31 * m22 * m43
+ m42 * m23 * m31)/Q;
/// 2
result.m12 = (- m12 * m44 * m33
+ m12 * m34 * m43
- m34 * m13 * m42
- m14 * m32 * m43
+ m44 * m13 * m32
+ m14 * m42 * m33)/Q;
result.m22 = (- m44 * m13 * m31
+ m44 * m11 * m33
- m34 * m11 * m43
- m14 * m41 * m33
+ m34 * m13 * m41
+ m14 * m31 * m43)/Q;
result.m32 = -(-m12 * m44 * m31
+ m12 * m34 * m41
+ m44 * m11 * m32
- m14 * m32 * m41
+ m14 * m42 * m31
- m34 * m11 * m42)/Q;
result.m42 = (- m12 * m31 * m43
+ m12 * m41 * m33
+ m11 * m32 * m43
- m11 * m42 * m33
- m41 * m13 * m32
+ m31 * m13 * m42)/Q;
/// 3
result.m13 = -( m44 * m13 * m22
- m24 * m13 * m42
- m14 * m22 * m43
+ m12 * m24 * m43
- m12 * m44 * m23
+ m14 * m42 * m23)/Q;
result.m23 = (- m21 * m14 * m43
+ m21 * m44 * m13
+ m24 * m11 * m43
- m44 * m23 * m11
- m24 * m41 * m13
+ m14 * m23 * m41)/Q;
result.m33 = -(-m44 * m11 * m22
+ m44 * m12 * m21
+ m14 * m41 * m22
+ m24 * m11 * m42
- m24 * m12 * m41
- m14 * m21 * m42)/Q;
result.m43 = -( m43 * m11 * m22
- m43 * m12 * m21
- m13 * m41 * m22
- m23 * m11 * m42
+ m23 * m12 * m41
+ m13 * m21 * m42)/Q;
/// 4
result.m14 = (- m12 * m34 * m23
+ m12 * m24 * m33
- m24 * m13 * m32
- m14 * m22 * m33
+ m34 * m13 * m22
+ m14 * m32 * m23)/Q;
result.m24 = -(-m21 * m14 * m33
+ m21 * m34 * m13
+ m24 * m11 * m33
- m34 * m23 * m11
+ m14 * m23 * m31
- m24 * m31 * m13)/Q;
result.m34 = (- m34 * m11 * m22
+ m34 * m12 * m21
+ m14 * m31 * m22
+ m24 * m11 * m32
- m24 * m12 * m31
- m14 * m21 * m32)/Q;
result.m44 = ( m33 * m11 * m22
- m33 * m12 * m21
- m13 * m31 * m22
- m23 * m11 * m32
+ m23 * m12 * m31
+ m13 * m21 * m32)/Q;
return result;
}
// DirectX
#ifdef USEDX
MATRIX4( const D3DXMATRIX& other ) : m11(other(0,0)), m12(other(0,1)), m13(other(0,2)),m14(other(0,3)),
m21(other(1,0)), m22(other(1,1)), m23(other(1,2)),m24(other(1,3)),
m31(other(2,0)), m32(other(2,1)), m33(other(2,2)),m34(other(2,3)),
m41(other(3,0)), m42(other(3,1)), m43(other(3,2)),m44(other(3,3)) {};
D3DXMATRIX toD3DXMAT() const {return D3DXMATRIX(FLOAT(m11),FLOAT(m12),FLOAT(m13),FLOAT(m14),
FLOAT(m21),FLOAT(m22),FLOAT(m23),FLOAT(m24),
FLOAT(m31),FLOAT(m32),FLOAT(m33),FLOAT(m34),
FLOAT(m41),FLOAT(m42),FLOAT(m43),FLOAT(m44));}
operator D3DXMATRIX(void) const {return toD3DXMAT();}
#endif
// OpenGL
#ifdef USEGL
static void BuildStereoLookAtAndProjection(const VECTOR3<T> vEye, const VECTOR3<T> vAt, const VECTOR3<T> vUp,
T fFOVY, T fAspect, T fZNear, T fZFar, T fFocalLength,
T fEyeDist, int iEyeID, MATRIX4<T>& mView, MATRIX4<T>& mProj) {
T radians = T(3.14159265358979323846/180.0) * fFOVY/T(2);
T wd2 = fZNear * T(tan(radians));
T nfdl = fZNear / fFocalLength;
T fShift = fEyeDist * nfdl;
T left = - fAspect * wd2 + T(iEyeID)*fShift;
T right = fAspect * wd2 + T(iEyeID)*fShift;
T top = wd2;
T bottom = - wd2;
// projection matrix
mProj.MatrixPerspectiveOffCenter(left, right, bottom, top, fZNear, fZFar);
// view matrix
mView.BuildLookAt(vEye, vAt, vUp);
MATRIX4<T> mTranslate;
mTranslate.Translation(fEyeDist*T(iEyeID), 0.0f, 0.0f);
mView= mTranslate * mView;
}
static void BuildStereoLookAtAndProjection(const VECTOR3<T> vEye, const VECTOR3<T> vAt, const VECTOR3<T> vUp,
T fFOVY, T fAspect, T fZNear, T fZFar, T fFocalLength,
T fEyeDist, MATRIX4<T>& mViewLeft, MATRIX4<T>& mViewRight, MATRIX4<T>& mProjLeft, MATRIX4<T>& mProjRight) {
T radians = T(3.14159265358979323846/180.0) * fFOVY/2;
T wd2 = fZNear * T(tan(radians));
T nfdl = fZNear / fFocalLength;
T fShift = fEyeDist * nfdl;
T left = - fAspect * wd2 + fShift;
T right = fAspect * wd2 + fShift;
T top = wd2;
T bottom = - wd2;
// projection matrices
mProjLeft.MatrixPerspectiveOffCenter(left, right, bottom, top, fZNear, fZFar);
left = - fAspect * wd2 - fShift;
right = fAspect * wd2 - fShift;
mProjRight.MatrixPerspectiveOffCenter(left, right, bottom, top, fZNear, fZFar);
// view matrices
mViewLeft.BuildLookAt(vEye, vAt, vUp);
mViewRight.BuildLookAt(vEye, vAt, vUp);
// eye translation
MATRIX4<T> mTranslate;
mTranslate.Translation(fEyeDist, 0.0f, 0.0f);
mViewLeft = mTranslate * mViewLeft;
mTranslate.Translation(-fEyeDist, 0.0f, 0.0f);
mViewRight = mTranslate * mViewRight;
}
void BuildLookAt(const VECTOR3<T> vEye, const VECTOR3<T> vAt, const VECTOR3<T> vUp) {
VECTOR3<T> F = vAt-vEye;
VECTOR3<T> U = vUp;
VECTOR3<T> S = F % U;
U = S % F;
F.normalize();
U.normalize();
S.normalize();
array[ 0]= S[0]; array[ 4]= S[1]; array[ 8]= S[2]; array[12]=-(S^vEye);
array[ 1]= U[0]; array[ 5]= U[1]; array[ 9]= U[2]; array[13]=-(U^vEye);
array[ 2]=-F[0]; array[ 6]=-F[1]; array[10]=-F[2]; array[14]= (F^vEye);
array[ 3]= T(0); array[ 7]=T(0); array[11]=T(0); array[15]= T(1);
}
void Perspective(T fovy, T aspect, T n, T f) {
// deg 2 rad
fovy = fovy * T(3.14159265358979323846/180.0);
T cotan = T(1.0/tan(double(fovy)/2.0));
array[ 0]= cotan/aspect; array[ 4]=T(0); array[ 8]=T(0); array[12]=T(0);
array[ 1]= T(0); array[ 5]=cotan; array[ 9]=T(0); array[13]=T(0);
array[ 2]= T(0); array[ 6]=T(0); array[10]=-(f+n)/(f-n); array[14]=T(-2)*(f*n)/(f-n);
array[ 3]= T(0); array[ 7]=T(0); array[11]=T(-1); array[15]=T(0);
}
void Ortho(T left, T right, T bottom, T top, T znear, T zfar ) {
array[ 0]= T(2)/(right-left); array[ 4]=T(0); array[ 8]=T(0); array[12]=-(right+left)/(right-left);
array[ 1]= T(0); array[ 5]=T(2)/(top-bottom); array[ 9]=T(0); array[13]=-(top+bottom)/(top-bottom);
array[ 2]= T(0); array[ 6]=T(0); array[10]=-T(2)/(zfar-znear); array[14]=-(zfar+znear)/(zfar-znear);
array[ 3]= T(0); array[ 7]=T(0); array[11]=T(0); array[15]=T(1);
}
void MatrixPerspectiveOffCenter(T left, T right, T bottom, T top, T n, T f) {
array[ 0]= T(2)*n/(right-left); array[ 4]=T(0); array[ 8]=(right+left)/(right-left); array[12]=T(0);
array[ 1]= T(0); array[ 5]=T(2)*n/(top-bottom); array[ 9]=(top+bottom)/(top-bottom); array[13]=T(0);
array[ 2]= T(0); array[ 6]=T(0); array[10]=-(f+n)/(f-n); array[14]=T(-2)*(f*n)/(f-n);
array[ 3]= T(0); array[ 7]=T(0); array[11]=T(-1); array[15]=T(0);
}
void getProjection() {
float P[16];
glGetFloatv(GL_PROJECTION_MATRIX,P);
for (int i=0;i<16;i++) array[i] = T(P[i]);
}
void getModelview() {
float M[16];
glGetFloatv(GL_MODELVIEW_MATRIX,M);
for (int i=0;i<16;i++) array[i] = T(M[i]);
}
void multModelview() {
float M[16];
for (int i=0;i<16;i++) M[i] = float(array[i]);
glMatrixMode(GL_MODELVIEW);
glMultMatrixf(M);
}
void setProjection() const {
float M[16];
for (int i=0;i<16;i++) M[i] = float(array[i]);
glMatrixMode(GL_PROJECTION);
glLoadMatrixf(M);
}
void setModelview() const {
float M[16];
for (int i=0;i<16;i++) M[i] = float(array[i]);
glMatrixMode(GL_MODELVIEW);
glLoadMatrixf(M);
}
void setTextureMatrix(int iUnit = 0) const {
float M[16];
for (int i=0;i<16;i++) M[i] = float(array[i]);
glActiveTextureARB(GL_TEXTURE0_ARB+iUnit);
glMatrixMode(GL_TEXTURE);
glLoadMatrixf(M);
}
#endif
};
template <class T>
std::istream& operator >>(std::istream &is, MATRIX4<T>& m)
{
is >> m.m11; is >> m.m12; is >> m.m13; is >> m.m14;
is >> m.m21; is >> m.m22; is >> m.m23; is >> m.m24;
is >> m.m31; is >> m.m32; is >> m.m33; is >> m.m34;
is >> m.m41; is >> m.m42; is >> m.m43; is >> m.m44;
return is;
}
typedef MATRIX2<int> INTMATRIX2;
typedef MATRIX3<int> INTMATRIX3;
typedef MATRIX4<int> INTMATRIX4;
typedef MATRIX2<float> FLOATMATRIX2;
typedef MATRIX3<float> FLOATMATRIX3;
typedef MATRIX4<float> FLOATMATRIX4;
typedef MATRIX2<double> DOUBLEMATRIX2;
typedef MATRIX3<double> DOUBLEMATRIX3;
typedef MATRIX4<double> DOUBLEMATRIX4;
template <class T> class QUATERNION4 {
public:
float x, y, z, w;
QUATERNION4<T>(): x(0), y(0),z(0), w(0) {}
QUATERNION4<T>(T _x, T _y, T _z, T _w): x(_x), y(_y), z(_z), w(_w) {}
QUATERNION4<T>(const T& other) : x(other.x), y(other.y), z(other.z), w(other.w) {}
MATRIX4<T> ComputeRotation() {
float n, s;
float xs, ys, zs;
float wx, wy, wz;
float xx, xy, xz;
float yy, yz, zz;
n = (x * x) + (y * y) + (z * z) + (w * w);
s = (n > 0.0f) ? (2.0f / n) : 0.0f;
xs = x * s;
ys = y * s;
zs = z * s;
wx = w * xs;
wy = w * ys;
wz = w * zs;
xx = x * xs;
xy = x * ys;
xz = x * zs;
yy = y * ys;
yz = y * zs;
zz = z * zs;
return MATRIX4<T>(T(1.0f - (yy + zz)), T(xy - wz), T(xz + wy), T(0),
T(xy + wz), T(1.0f - (xx + zz)), T(yz - wx), T(0),
T(xz - wy), T(yz + wx), T(1.0f - (xx + yy)), T(0),
T(0), T(0), T(0), T(1));
}
bool operator == ( const QUATERNION4<T>& other ) const {return (other.x==x && other.y==y && other.z==z && other.w==w); }
bool operator != ( const QUATERNION4<T>& other ) const {return (other.x!=x || other.y!=y || other.z!=z || other.w!=w); }
// binary operators with other quaternions
QUATERNION4<T> operator + ( const QUATERNION4<T>& other ) const {return QUATERNION4<T>(x+other.x,y+other.y,z+other.z,w+other.w);}
QUATERNION4<T> operator - ( const QUATERNION4<T>& other ) const {return QUATERNION4<T>(x-other.x,y-other.y,z-other.z,w-other.w);}
QUATERNION4<T> operator * ( const QUATERNION4<T>& other ) const {
VECTOR3<T> v1(x,y,z);
VECTOR3<T> v2(other.x,other.y,other.z);
T _w = w * other.w - (v1 ^ v2);
VECTOR3<T> _v = (v2 * w) + (v1 * other.w) + (v1 % v2);
return QUATERNION4<T>(_v.x, _v.y, _v.z, _w);
}
// binary operator with scalars
QUATERNION4<T> operator * ( const T other ) const {
return QUATERNION4<T>(x*other,y*other,z*other,w*other);
}
QUATERNION4<T>& operator=(const QUATERNION4<T>& other) { x = other.x; y = other.y; z = other.z; w = other.w; return *this; }
QUATERNION4<T>& operator+=(const T& other) { x += other; y += other; z += other; w += other; return *this; }
QUATERNION4<T>& operator-=(const T& other) { x -= other; y -= other; z -= other; w -= other; return *this; }
};
typedef QUATERNION4<float> FLOATQUATERNION4;
typedef QUATERNION4<double> DOUBLEQUATERNION4;
/// Tests to see if the two values are basically the same.
template <class T> static bool EpsilonEqual(T a, T b) {
/// @todo FIXME provide specializations for types; currently this would only
/// be correct if instantiated as a float!
return fabs(a-b) <= std::numeric_limits<T>::epsilon();
}
/// a PLANE is a VECTOR4 which is always normalized.
template <class T> class PLANE : public VECTOR4<T> {
public:
PLANE<T>(): VECTOR4<T>(0,0,0,0) {}
// plane from paramters (usually all 4 are given)
template <class S> explicit PLANE<T>( const std::vector<S>& v ) {
this->x = T(v.size()>0 ? v[0] : 0);
this->y = T(v.size()>1 ? v[1] : 0);
this->z = T(v.size()>2 ? v[2] : 0);
this->w = T(v.size()>3 ? v[3] : 0);
}
// plane from points
template <class S> explicit PLANE<T>( const VECTOR3<S>& v0, const VECTOR3<S>& v1, const VECTOR3<S>& v2 ) {
this->x = T(v0.y) * (T(v1.z) - T(v2.z)) + T(v1.y) * (T(v2.z) - T(v0.z)) + T(v2.y) * (T(v0.z) - T(v1.z));
this->y = T(v0.z) * (T(v1.x) - T(v2.x)) + T(v1.z) * (T(v2.x) - T(v0.x)) + T(v2.z) * (T(v0.x) - T(v1.x));
this->z = T(v0.x) * (T(v1.y) - T(v2.y)) + T(v1.x) * (T(v2.y) - T(v0.y)) + T(v2.x) * (T(v0.y) - T(v1.y));
this->w = - (T(v0.x) * (T(v1.y) * T(v2.z) - T(v2.y) * T(v1.z)) +
T(v1.x) * (T(v2.y) * T(v0.z) - T(v0.y) * T(v2.z)) +
T(v2.x) * (T(v0.y) * T(v1.z) - T(v1.y) * T(v0.z)));
}
PLANE<T>(const VECTOR2<T> &other, const T _z, const T _w):
VECTOR4<T>(other, _z, _w) {}
PLANE<T>(const VECTOR3<T> &other, const T _w = 1): VECTOR4<T>(other, _w) {}
PLANE<T>(const VECTOR4<T> &other): VECTOR4<T>(other) {}
template <class S> explicit PLANE<T>(const PLANE<S> &other):
VECTOR4<T>(other) {}
PLANE<T>(const T _x, const T _y, const T _z, const T _w) :
VECTOR4<T>(_x,_y,_z,_w) {}
PLANE<T>(const T* vec) : VECTOR4<T>(vec) {}
/// @return true if the given point is clipped by this plane.
bool clip(VECTOR3<T> point) const {
return ((FLOATVECTOR4::xyz() ^ point)+this->w >= 0);
}
/// Transform the plane by the given matrix.
void transform(const MATRIX4<T> &m) {
FLOATMATRIX4 mIT(m.inverse());
mIT = mIT.Transpose();
transformIT(mIT);
}
/// Transform the plane by the inverse transpose of the given matrix.
void transformIT(const MATRIX4<T> &M) {
(*this) = FLOATVECTOR4::operator*(M);
normalize();
}
void normalize() {
const T x = this->x;
const T y = this->y;
const T z = this->z;
T length = sqrt(x*x + y*y + z*z);
(*this) /= length;
}
T d() const { return this->w; }
VECTOR3<T> normal() { return this->xyz(); }
// binary operators with a matrix
PLANE<T> operator * ( const MATRIX4<T>& matrix ) const {
PLANE<T> tmp(*this);
tmp.transform(matrix);
return tmp;
}
/// Determine the intersection point of the plane and a line `ab'.
/// @return whether or not the two intersect. If false, `hit' will not be
/// valid.
bool intersect(const VECTOR3<T>& a, const VECTOR3<T>& b,
VECTOR3<T>& hit) const {
T t;
bool bIntersect = intersect(a,b,t);
if (!bIntersect) return false;
hit = a + (t*(b - a));
return true;
}
/// Determine the parametric intersection point of the plane and a line `ab'.
/// @return whether or not the two intersect. If false, `hit' will not be
/// valid.
bool intersect(const VECTOR3<T>& a, const VECTOR3<T>& b,
T& hit) const {
const T denom = (*this) ^ (a - b);
if(EpsilonEqual(denom, 0.0f)) {
return false;
}
hit = (((*this) ^ a) + this->d()) / denom;
return true;
}
};
// Structure describing blob from affine adaption
struct AffineBlob
{
FLOATVECTOR3 vCenter;
FLOATVECTOR3 vEigenValues;
float fMaxAxis; // The longest axis
FLOATMATRIX3 matRotation;
};
struct Marker
{
FLOATVECTOR2 startPos;
FLOATVECTOR2 endPos;
int value;
bool horizontal;
};
struct AABB2D
{
FLOATVECTOR2 vMin;
FLOATVECTOR2 vMax;
};
struct UINT64AABB3D
{
UINT64VECTOR3 vMin;
UINT64VECTOR3 vMax;
};
struct FLOATAABB3D
{
FLOATVECTOR3 vMin;
FLOATVECTOR3 vMax;
};
class Brick {
public:
Brick() :
vCenter(0,0,0),
vExtension(0,0,0),
vVoxelCount(0, 0, 0),
vCoords(0,0,0),
fDistance(0),
bIsEmpty(false)
{
}
Brick(UINT32 x, UINT32 y, UINT32 z,
UINT32 iSizeX, UINT32 iSizeY, UINT32 iSizeZ) :
vCenter(0,0,0),
vExtension(0,0,0),
vVoxelCount(iSizeX, iSizeY, iSizeZ),
vCoords(x,y,z),
fDistance(0),
bIsEmpty(false)
{
}
FLOATVECTOR3 vCenter;
FLOATVECTOR3 vTexcoordsMin;
FLOATVECTOR3 vTexcoordsMax;
FLOATVECTOR3 vExtension;
UINTVECTOR3 vVoxelCount;
UINTVECTOR3 vCoords;
float fDistance;
bool bIsEmpty;
};
inline bool operator < (const Brick& left, const Brick& right) {
if (left.fDistance < right.fDistance) return true;
return false;
}
enum EWindowMode {
WM_SAGITTAL = 0, // It is showing x slice
WM_CORONAL = 1, // Shows y slice
WM_AXIAL = 2, // Shows z slice
WM_3D,
WM_INVALID
};
typedef PLANE<float> FLOATPLANE;
typedef PLANE<double> DOUBLEPLANE;
// A crappy structure to avoid sending GLTexture across projects.
class TextureInfo
{
public:
TextureInfo():
size(0, 0, 0),
sizePerElement(0),
format(0),
internalFormat(0),
type(0),
data(0),
totalElements(0)
{}
UINTVECTOR3 size;
UINT32 sizePerElement;
UINT32 format;
int internalFormat;
UINT32 type;
unsigned char* data;
UINT64 totalElements; // How many voxels are contained in a histogram texture? Only used when passing histogram textures.
};
class GLTextureArray2D;
class GLTexture2D;
class GLTextureArray1D;
class HistogramImagesInfo
{
public:
HistogramImagesInfo():
histogramTex(NULL),
histogramCountTex(NULL),
histogram1DArrayTex(NULL),
deepIdTex(NULL)
{}
GLTextureArray2D* histogramTex; // joint conditional histogram texture
GLTexture2D* histogramCountTex; // cond histo count texture
GLTextureArray1D* histogram1DArrayTex; // Simply 1D histograms for all axises used in unconditional histograms computation.
GLTextureArray2D* deepIdTex; // deep id texture used in multivariate2d mode
FLOATVECTOR4 color;
};
class GLTextureArray1D;
class GLFBOTex;
class MultivariateTFInfo
{
public:
GLTextureArray1D* multivariateTFTex; // The TF texture
GLFBOTex* fboTex; // 2d fbo version of the tf texture
float* weights; // The weight of each axises
};
class MultigroupTFInfo
{
public:
GLTextureArray2D* multigroupMTFTex;
GLFBOTex* idMapTex;
size_t groupNum;
};
class GLFBO3DTex;
class MultivariateTF2DInfo
{
public:
GLTextureArray2D* multivariateTF2DTex; // The 2D TF texture array
GLTextureArray2D* deepIdMapTex; // The id map 2d texture array
int widgetID; // deep widget id
};
class MultivariateGaussTFInfo
{
public:
MultivariateGaussTFInfo(): gaussMeans(NULL), gaussSD(NULL){}
~MultivariateGaussTFInfo()
{
SAFE_DELETE_ARRAY(gaussSD);
SAFE_DELETE_ARRAY(gaussMeans);
}
FLOATVECTOR4 gaussColor;
float* gaussMeans; // mean
float* gaussSD; // standard deviation
size_t groupNum;
};
struct PVertex2D
{
FLOATVECTOR2 pos;
};
struct PIVertex2D
{
FLOATVECTOR2 pos;
float intensity;
};
struct PCVertex2D
{
FLOATVECTOR2 pos;
FLOATVECTOR4 color;
};
#endif // VECTORS_H
| [
"[email protected]"
] | |
4090667b85fb6d355f664a5fda63a4ae8b7ff529 | d0c44dd3da2ef8c0ff835982a437946cbf4d2940 | /cmake-build-debug/programs_tiling/function13829/function13829_schedule_20/function13829_schedule_20_wrapper.cpp | 43b0d7ca2a166c2daefe766aefded8535c4c93ca | [] | no_license | IsraMekki/tiramisu_code_generator | 8b3f1d63cff62ba9f5242c019058d5a3119184a3 | 5a259d8e244af452e5301126683fa4320c2047a3 | refs/heads/master | 2020-04-29T17:27:57.987172 | 2019-04-23T16:50:32 | 2019-04-23T16:50:32 | 176,297,755 | 1 | 2 | null | null | null | null | UTF-8 | C++ | false | false | 1,263 | cpp | #include "Halide.h"
#include "function13829_schedule_20_wrapper.h"
#include "tiramisu/utils.h"
#include <cstdlib>
#include <iostream>
#include <time.h>
#include <fstream>
#include <chrono>
#define MAX_RAND 200
int main(int, char **){
Halide::Buffer<int32_t> buf00(128);
Halide::Buffer<int32_t> buf01(128);
Halide::Buffer<int32_t> buf02(512);
Halide::Buffer<int32_t> buf03(512);
Halide::Buffer<int32_t> buf04(512, 128);
Halide::Buffer<int32_t> buf05(512, 128);
Halide::Buffer<int32_t> buf0(512, 512, 128);
init_buffer(buf0, (int32_t)0);
auto t1 = std::chrono::high_resolution_clock::now();
function13829_schedule_20(buf00.raw_buffer(), buf01.raw_buffer(), buf02.raw_buffer(), buf03.raw_buffer(), buf04.raw_buffer(), buf05.raw_buffer(), buf0.raw_buffer());
auto t2 = std::chrono::high_resolution_clock::now();
std::chrono::duration<double> diff = t2 - t1;
std::ofstream exec_times_file;
exec_times_file.open("../data/programs/function13829/function13829_schedule_20/exec_times.txt", std::ios_base::app);
if (exec_times_file.is_open()){
exec_times_file << diff.count() * 1000000 << "us" <<std::endl;
exec_times_file.close();
}
return 0;
} | [
"[email protected]"
] | |
175f6b3b5b78575387da6e138b20a96664866be2 | 488a79e8350ae8ca7ecddbf8344a6cc16a350f43 | /src/qt/askpassphrasedialog.cpp | 34eba4c3fc6f331fde88b22489169edaab8dee20 | [
"MIT"
] | permissive | zahidaliayub/BTCB | 75584455803b6edd91daee2ed5c701af486baa65 | a86c29a9e6d47b6b91cf0650d4972aeae0ad7d33 | refs/heads/master | 2021-09-02T05:11:09.477376 | 2017-11-23T21:40:03 | 2017-11-23T21:40:03 | 115,811,538 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 10,264 | cpp | #include "askpassphrasedialog.h"
#include "ui_askpassphrasedialog.h"
#include "guiconstants.h"
#include "walletmodel.h"
#include <QMessageBox>
#include <QPushButton>
#include <QKeyEvent>
extern bool fWalletUnlockStakingOnly;
AskPassphraseDialog::AskPassphraseDialog(Mode mode, QWidget *parent) :
QDialog(parent),
ui(new Ui::AskPassphraseDialog),
mode(mode),
model(0),
fCapsLock(false)
{
ui->setupUi(this);
ui->passEdit1->setMaxLength(MAX_PASSPHRASE_SIZE);
ui->passEdit2->setMaxLength(MAX_PASSPHRASE_SIZE);
ui->passEdit3->setMaxLength(MAX_PASSPHRASE_SIZE);
// Setup Caps Lock detection.
ui->passEdit1->installEventFilter(this);
ui->passEdit2->installEventFilter(this);
ui->passEdit3->installEventFilter(this);
ui->stakingCheckBox->setChecked(fWalletUnlockStakingOnly);
switch(mode)
{
case Encrypt: // Ask passphrase x2
ui->passLabel1->hide();
ui->passEdit1->hide();
ui->warningLabel->setText(tr("Enter the new passphrase to the wallet.<br/>Please use a passphrase of <b>ten or more random characters</b>, or <b>eight or more words</b>."));
setWindowTitle(tr("Encrypt wallet"));
break;
case UnlockStaking:
ui->stakingCheckBox->setChecked(true);
ui->stakingCheckBox->show();
// fallthru
case Unlock: // Ask passphrase
ui->warningLabel->setText(tr("This operation needs your wallet passphrase to unlock the wallet."));
ui->passLabel2->hide();
ui->passEdit2->hide();
ui->passLabel3->hide();
ui->passEdit3->hide();
setWindowTitle(tr("Unlock wallet"));
break;
case Decrypt: // Ask passphrase
ui->warningLabel->setText(tr("This operation needs your wallet passphrase to decrypt the wallet."));
ui->passLabel2->hide();
ui->passEdit2->hide();
ui->passLabel3->hide();
ui->passEdit3->hide();
setWindowTitle(tr("Decrypt wallet"));
break;
case ChangePass: // Ask old passphrase + new passphrase x2
setWindowTitle(tr("Change passphrase"));
ui->warningLabel->setText(tr("Enter the old and new passphrase to the wallet."));
break;
}
textChanged();
connect(ui->passEdit1, SIGNAL(textChanged(QString)), this, SLOT(textChanged()));
connect(ui->passEdit2, SIGNAL(textChanged(QString)), this, SLOT(textChanged()));
connect(ui->passEdit3, SIGNAL(textChanged(QString)), this, SLOT(textChanged()));
}
AskPassphraseDialog::~AskPassphraseDialog()
{
secureClearPassFields();
delete ui;
}
void AskPassphraseDialog::setModel(WalletModel *model)
{
this->model = model;
}
void AskPassphraseDialog::accept()
{
SecureString oldpass, newpass1, newpass2;
if(!model)
return;
oldpass.reserve(MAX_PASSPHRASE_SIZE);
newpass1.reserve(MAX_PASSPHRASE_SIZE);
newpass2.reserve(MAX_PASSPHRASE_SIZE);
// TODO: get rid of this .c_str() by implementing SecureString::operator=(std::string)
// Alternately, find a way to make this input mlock()'d to begin with.
oldpass.assign(ui->passEdit1->text().toStdString().c_str());
newpass1.assign(ui->passEdit2->text().toStdString().c_str());
newpass2.assign(ui->passEdit3->text().toStdString().c_str());
secureClearPassFields();
switch(mode)
{
case Encrypt: {
if(newpass1.empty() || newpass2.empty())
{
// Cannot encrypt with empty passphrase
break;
}
QMessageBox::StandardButton retval = QMessageBox::question(this, tr("Confirm wallet encryption"),
tr("Warning: If you encrypt your wallet and lose your passphrase, you will <b>LOSE ALL OF YOUR COINS</b>!") + "<br><br>" + tr("Are you sure you wish to encrypt your wallet?"),
QMessageBox::Yes|QMessageBox::Cancel,
QMessageBox::Cancel);
if(retval == QMessageBox::Yes)
{
if(newpass1 == newpass2)
{
if(model->setWalletEncrypted(true, newpass1))
{
QMessageBox::warning(this, tr("Wallet encrypted"),
"<qt>" +
tr("BTC Blue will close now to finish the encryption process. "
"Remember that encrypting your wallet cannot fully protect "
"your coins from being stolen by malware infecting your computer.") +
"<br><br><b>" +
tr("IMPORTANT: Any previous backups you have made of your wallet file "
"should be replaced with the newly generated, encrypted wallet file. "
"For security reasons, previous backups of the unencrypted wallet file "
"will become useless as soon as you start using the new, encrypted wallet.") +
"</b></qt>");
QApplication::quit();
}
else
{
QMessageBox::critical(this, tr("Wallet encryption failed"),
tr("Wallet encryption failed due to an internal error. Your wallet was not encrypted."));
}
QDialog::accept(); // Success
}
else
{
QMessageBox::critical(this, tr("Wallet encryption failed"),
tr("The supplied passphrases do not match."));
}
}
else
{
QDialog::reject(); // Cancelled
}
} break;
case UnlockStaking:
case Unlock:
if(!model->setWalletLocked(false, oldpass))
{
QMessageBox::critical(this, tr("Wallet unlock failed"),
tr("The passphrase entered for the wallet decryption was incorrect."));
}
else
{
fWalletUnlockStakingOnly = ui->stakingCheckBox->isChecked();
QDialog::accept(); // Success
}
break;
case Decrypt:
if(!model->setWalletEncrypted(false, oldpass))
{
QMessageBox::critical(this, tr("Wallet decryption failed"),
tr("The passphrase entered for the wallet decryption was incorrect."));
}
else
{
QDialog::accept(); // Success
}
break;
case ChangePass:
if(newpass1 == newpass2)
{
if(model->changePassphrase(oldpass, newpass1))
{
QMessageBox::information(this, tr("Wallet encrypted"),
tr("Wallet passphrase was successfully changed."));
QDialog::accept(); // Success
}
else
{
QMessageBox::critical(this, tr("Wallet encryption failed"),
tr("The passphrase entered for the wallet decryption was incorrect."));
}
}
else
{
QMessageBox::critical(this, tr("Wallet encryption failed"),
tr("The supplied passphrases do not match."));
}
break;
}
}
void AskPassphraseDialog::textChanged()
{
// Validate input, set Ok button to enabled when acceptable
bool acceptable = false;
switch(mode)
{
case Encrypt: // New passphrase x2
acceptable = !ui->passEdit2->text().isEmpty() && !ui->passEdit3->text().isEmpty();
break;
case UnlockStaking:
case Unlock: // Old passphrase x1
case Decrypt:
acceptable = !ui->passEdit1->text().isEmpty();
break;
case ChangePass: // Old passphrase x1, new passphrase x2
acceptable = !ui->passEdit1->text().isEmpty() && !ui->passEdit2->text().isEmpty() && !ui->passEdit3->text().isEmpty();
break;
}
ui->buttonBox->button(QDialogButtonBox::Ok)->setEnabled(acceptable);
}
bool AskPassphraseDialog::event(QEvent *event)
{
// Detect Caps Lock key press.
if (event->type() == QEvent::KeyPress) {
QKeyEvent *ke = static_cast<QKeyEvent *>(event);
if (ke->key() == Qt::Key_CapsLock) {
fCapsLock = !fCapsLock;
}
if (fCapsLock) {
ui->capsLabel->setText(tr("Warning: The Caps Lock key is on!"));
} else {
ui->capsLabel->clear();
}
}
return QWidget::event(event);
}
bool AskPassphraseDialog::eventFilter(QObject *object, QEvent *event)
{
/* Detect Caps Lock.
* There is no good OS-independent way to check a key state in Qt, but we
* can detect Caps Lock by checking for the following condition:
* Shift key is down and the result is a lower case character, or
* Shift key is not down and the result is an upper case character.
*/
if (event->type() == QEvent::KeyPress) {
QKeyEvent *ke = static_cast<QKeyEvent *>(event);
QString str = ke->text();
if (str.length() != 0) {
const QChar *psz = str.unicode();
bool fShift = (ke->modifiers() & Qt::ShiftModifier) != 0;
if ((fShift && psz->isLower()) || (!fShift && psz->isUpper())) {
fCapsLock = true;
ui->capsLabel->setText(tr("Warning: The Caps Lock key is on!"));
} else if (psz->isLetter()) {
fCapsLock = false;
ui->capsLabel->clear();
}
}
}
return QDialog::eventFilter(object, event);
}
void AskPassphraseDialog::secureClearPassFields()
{
// Attempt to overwrite text so that they do not linger around in memory
ui->passEdit1->setText(QString(" ").repeated(ui->passEdit1->text().size()));
ui->passEdit2->setText(QString(" ").repeated(ui->passEdit2->text().size()));
ui->passEdit3->setText(QString(" ").repeated(ui->passEdit3->text().size()));
ui->passEdit1->clear();
ui->passEdit2->clear();
ui->passEdit3->clear();
}
| [
"[email protected]"
] | |
14b200550966489197ec87688aeee4d910f29043 | ebd1570fa57094fd5b24889b1e657fcf6a1d9fc6 | /MapDesigner/MapDesigner.cpp | 4d8ab7bc454a59c3f93d8bbc3d0bba88299167e0 | [] | no_license | LinkClinton/MapDesigner | 78987b1e44a377d52afe2cd8e466e2ca579cbe4b | 8daca145580d8ba02325a51ebc2e5b77152a344b | refs/heads/master | 2020-03-23T14:10:23.665233 | 2018-07-20T05:44:18 | 2018-07-20T05:44:18 | 141,660,956 | 0 | 0 | null | null | null | null | GB18030 | C++ | false | false | 9,300 | cpp | #include "MapDesigner.hpp"
#include "TextObject.hpp"
#include "Helper.hpp"
#define CAMERA_MOVE_SPEED 200.0f
#define CAMERA_TIMES_LIMIT 2.0f
#define CAMERA_WHEEL_SPEED 0.1f
#define MAX_CHAR_COUNT 1000
void MapDesigner::CreateObject()
{
commandArea = new CommandArea("CommandArea", this);
commandArea->SetSize(WINDOW_WIDTH - RENDER_OBJECT_AREA_WIDTH + 1, COMMAND_AREA_HEIGHT);
commandArea->SetPosition(0, WINDOW_HEIGHT - commandArea->GetHeight());
commandArea->SetBorderWidth(1);
commandArea->SetBorderColor(0, 0, 0);
commandArea->SetText("");
world->RegisterUIObject(commandArea);
renderObjectArea = new RenderObjectArea("RenderObjectArea", this);
renderObjectArea->SetSize(RENDER_OBJECT_AREA_WIDTH, WINDOW_HEIGHT);
renderObjectArea->SetPosition(WINDOW_WIDTH - renderObjectArea->GetWidth(), 0);
renderObjectArea->SetBorderWidth(1);
renderObjectArea->SetBorderColor(0, 0, 0);
world->RegisterUIObject(renderObjectArea);
}
void MapDesigner::CreateTextureManager()
{
textureManager = new TextureManager(application);
textMergeTexture = new AutoMergeTexture(application,
TEXT_AUTO_MERGETEXTURE_WIDTHLIMIT, TEXT_AUTO_MERGETEXTURE_HEIGHTLIMIT, TEXT_AUTO_MERGETEXTURE_COUNT,
PixelFormat::A8);
defaultMergeTexture = new AutoMergeTexture(application,
100, 100, 5, PixelFormat::R8G8B8A8);
defaultMergeTexture->AddTexture(DEFAULT_MAP_RENDER_OBJECT_ID,
resourceManager->dataManager->RegisterTexture(DEFAULT_MAP_RENDER_OBJECT_FILE));
defaultMergeTexture->AddTexture(DEFAULT_BACK_GROUND_ID,
resourceManager->dataManager->RegisterTexture(DEFAULT_BACK_GROUND_FILE));
textureManager->AddMergeTexture(0, resourceManager->GetMergeTexture());
textureManager->AddMergeTexture(1, textMergeTexture->GetMergeTexture());
textureManager->AddMergeTexture(2, defaultMergeTexture->GetMergeTexture());
world->SetTextureManager(textureManager);
}
void MapDesigner::DestoryObject()
{
Utility::Delete(commandArea);
Utility::Delete(renderObjectArea);
}
void MapDesigner::DestoryTextureManager()
{
Utility::Delete(textMergeTexture);
Utility::Delete(defaultMergeTexture);
Utility::Delete(textureManager);
}
void MapDesigner::LoadConfig()
{
std::ifstream file;
file.open(GLOBAL_CONFIG_FILE);
if (!file) return;
char data[MAX_CHAR_COUNT];
while (file.getline(data, MAX_CHAR_COUNT)) {
auto parameters = Helper::SpiltString(data);
if (parameters.size() != 2) continue;
parameters[0] = Helper::ToUpperString(parameters[0]);
if (parameters[0] == MAP_FILE)
mapManager->OpenMap(parameters[1]);
if (parameters[0] == RESOURCE_CONFIG_FILE)
resourceManager->OpenResourceConfig(parameters[1]);
if (parameters[0] == SSAA_FILE) {
if (Helper::IsNumber(parameters[1]) == false) ERROR_RETURN("配置文件的SSAA抗锯齿倍数错误，不是整数。");
ssaa = (float)Helper::StringToInt(parameters[1]);
}
}
file.close();
}
void MapDesigner::SetMap()
{
if (mapManager->map == nullptr) return;
world->SetWorldMap(mapManager->map);
for (auto it = operations.begin(); it != operations.end(); it++)
Utility::Delete(it->nextMapData);
operations.clear();
}
void MapDesigner::SetResourceConfig()
{
if (resourceManager->resources.size() == 0) return;
renderObjectArea->ClearRenderObject();
for (auto it = resourceManager->resources.begin(); it != resourceManager->resources.end(); it++)
renderObjectArea->AddRenderObject(it->renderObjectID);
textureManager->AddMergeTexture(0, resourceManager->mergeTexture);
}
void MapDesigner::SetMapData(int mousePositionX, int mousePositionY)
{
if (mapManager->map == nullptr) return;
auto cameraRect = mainCamera->GetRectangle();
float x = ((float)mousePositionX / WINDOW_WIDTH) * (cameraRect.right - cameraRect.left) + cameraRect.left;
float y = ((float)mousePositionY / WINDOW_HEIGHT) * (cameraRect.bottom - cameraRect.top) + cameraRect.top;
auto index = mapManager->map->GetWorldMapDataIndex(x, y);
if (index == mapManager->map->InvalidLocation()) return;
Operation record;
record.x = index.first;
record.y = index.second;
record.lastMapData = mapManager->map->GetMapData(index.first, index.second);
record.nextMapData = new MapData();
record.nextMapData->RenderObjectID = RenderObjectItem::GetFocusRenderObjectID();
mapManager->map->SetMapData(index.first, index.second, record.nextMapData);
operations.push_back(record);
}
void MapDesigner::BackSetMapData()
{
if (operations.size() == 0) return;
auto record = operations[operations.size() - 1];
mapManager->map->SetMapData(record.x, record.y, record.lastMapData);
Utility::Delete(record.nextMapData);
operations.pop_back();
}
void MapDesigner::OnUpdate(void * sender)
{
auto application = (ApplicationEx*)sender;
auto mapDesigner = application->mapDesigner;
application->SetWindow(mapDesigner->name + " FPS: " + Utility::ToString(application->GetFramePerSecond()), WINDOW_WIDTH, WINDOW_HEIGHT);
auto deltaTime = application->GetDeltaTime();
glm::vec2 translate = glm::vec2(0, 0);
if (Input::GetKeyCodeDown(KeyCode::A) == true)
translate.x -= 1;
if (Input::GetKeyCodeDown(KeyCode::D) == true)
translate.x += 1;
if (Input::GetKeyCodeDown(KeyCode::S) == true)
translate.y += 1;
if (Input::GetKeyCodeDown(KeyCode::W) == true)
translate.y -= 1;
if (translate != glm::vec2(0, 0) && mapDesigner->commandArea->IsEnableRead() == false) {
translate = glm::normalize(translate) * CAMERA_MOVE_SPEED * deltaTime * mapDesigner->mainCameraTimes;
mapDesigner->mainCamera->Move(translate);
}
}
void MapDesigner::OnKeyDownEvent(void * sender, Events::KeyClickEvent * eventArg)
{
if (eventArg->isDown == false) return;
auto application = (ApplicationEx*)sender;
auto mapDesigner = application->mapDesigner;
if (eventArg->keyCode == KeyCode::Tab)
mapDesigner->commandArea->EnableRead(!mapDesigner->commandArea->IsEnableRead());
if (eventArg->keyCode == KeyCode::Z && Input::GetKeyCodeDown(KeyCode::ControlKey) == true)
mapDesigner->BackSetMapData();
mapDesigner->commandArea->OnReadCommand(mapDesigner->commandArea, eventArg);
}
void MapDesigner::OnMouseDownEvent(void * sender, Events::MouseClickEvent * eventArg)
{
if (eventArg->isDown == false) return;
auto application = (ApplicationEx*)sender;
auto mapDesigner = application->mapDesigner;
auto commandArea = mapDesigner->commandArea;
if (eventArg->button == Events::MouseButton::Left) {
auto rect = PixelWorldEngine::RectangleF(commandArea->GetPositionX(),
commandArea->GetPositionY(),
commandArea->GetPositionX() + commandArea->GetWidth(),
commandArea->GetPositionY() + commandArea->GetHeight());
if (eventArg->x >= rect.left && eventArg->x <= rect.right &&
eventArg->y >= rect.top && eventArg->y <= rect.bottom)
commandArea->EnableRead(true);
else commandArea->EnableRead(false);
if (eventArg->x >= 0 && eventArg->x <= WINDOW_WIDTH - RENDER_OBJECT_AREA_WIDTH &&
eventArg->y >= 0 && eventArg->y <= WINDOW_HEIGHT - COMMAND_AREA_HEIGHT) {
mapDesigner->SetMapData(eventArg->x, eventArg->y);
}
}
}
void MapDesigner::OnMouseWheel(void * sender, Events::MouseWheelEvent * eventArg)
{
auto application = (ApplicationEx*)sender;
auto mapDesigner = application->mapDesigner;
if (eventArg->x >= 0 && eventArg->x <= WINDOW_WIDTH - RENDER_OBJECT_AREA_WIDTH &&
eventArg->y >= 0 && eventArg->y <= WINDOW_HEIGHT - COMMAND_AREA_HEIGHT) {
float offset = -((short)eventArg->offset) * CAMERA_WHEEL_SPEED * mapDesigner->application->GetDeltaTime();
mapDesigner->mainCameraTimes = Utility::Limit(mapDesigner->mainCameraTimes + offset, 1.0f, CAMERA_TIMES_LIMIT);
auto cameraRect = mapDesigner->mainCamera->GetRectangle();
float positionX = (cameraRect.right - cameraRect.left) * 0.5f + cameraRect.left;
float positionY = (cameraRect.bottom - cameraRect.top) * 0.5f + cameraRect.top;
float halfWidth = WINDOW_WIDTH * 0.5f * mapDesigner->mainCameraTimes;
float halfHeight = WINDOW_HEIGHT * 0.5f * mapDesigner->mainCameraTimes;
mapDesigner->mainCamera->SetFocus(positionX, positionY,
PixelWorldEngine::RectangleF(halfWidth, halfHeight, halfWidth, halfHeight));
}
}
MapDesigner::MapDesigner()
{
application = new ApplicationEx(name, this);
world = new PixelWorld(name, application);
mapManager = new MapManager();
resourceManager = new ResourceManager(application);
mainCamera = new Camera(PixelWorldEngine::RectangleF(0, 0, WINDOW_WIDTH, WINDOW_HEIGHT));
mainCameraTimes = 1.0f;
ssaa = SSAA;
}
MapDesigner::~MapDesigner()
{
DestoryObject();
DestoryTextureManager();
Utility::Delete(mainCamera);
Utility::Delete(world);
Utility::Delete(mapManager);
Utility::Delete(resourceManager);
Utility::Delete(application);
}
void MapDesigner::Initialize()
{
LoadConfig();
CreateTextureManager();
TextObject::Create(textMergeTexture);
CreateObject();
world->SetResolution(WINDOW_WIDTH, WINDOW_HEIGHT, ssaa);
world->SetCamera(mainCamera);
application->SetWorld(world);
application->Update.push_back(OnUpdate);
application->KeyClick.push_back(OnKeyDownEvent);
application->MouseClick.push_back(OnMouseDownEvent);
application->MouseWheel.push_back(OnMouseWheel);
application->MakeWindow(name, WINDOW_WIDTH, WINDOW_HEIGHT);
application->ShowWindow();
SetMap();
SetResourceConfig();
}
void MapDesigner::RunLoop()
{
application->RunLoop();
}
| [
"[email protected]"
] | |
28ab63b5d0531772414c6d55f2a9daa2008f0211 | 3b1d08997d0dc9c444f2bdaaab55a8606c60d332 | /IOCMain/CMXWrap/RTC.cpp | 63a73f4e9ca2ae384e29758e8d2cf0c5b63afc4d | [] | no_license | zjsaisi/sm2000 | 8303ece373516c871694d382bb3daef9f5129d1a | 0fa74cdb7566621162e1845dd4558723182a49ac | refs/heads/master | 2020-04-16T09:22:12.797424 | 2019-01-23T10:31:07 | 2019-01-23T10:31:07 | 165,461,667 | 0 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 6,469 | cpp | // RTC.cpp: implementation of the CRTC class.
//
//////////////////////////////////////////////////////////////////////
/*
* Real Time Clock management
* $Header: RTC.cpp 1.2 2009/05/05 13:32:32PDT Zheng Miao (zmiao) Exp $
* $Revision: 1.2 $
*
*/
#include "iodefine.h"
#include "cxfuncs.h"
#include "CodeOpt.h"
#include "DataType.h"
#include "RTC.h"
#include "machine.h"
#include "Constdef.h"
#include "AllProcess.h"
#include "g_cmx.h"
#include "PTPIsr.h"
#include "sci.h"
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
#define MJD_1_6_1980 44244
#define MJD_1_1_1970 40587
#pragma section RTC
static volatile unsigned long g_previousTime;
static volatile unsigned long _g_previousTime;
volatile unsigned long g_systemTicks; // Don't move this to .h file.
// Otherwise the sequence will be changed.
#pragma section
CRTC *g_pRTC;
CRTC::CRTC()
{
if (g_previousTime == ~_g_previousTime) {
m_seconds_1970 = g_previousTime;
} else {
m_seconds_1970 = 315964800L; // 1/6/1980
}
m_absoluteSecond = 0L;
}
CRTC::~CRTC()
{
}
void CRTC::TickOfOneSecond()
{
unsigned char temp_exr = get_exr();
set_exr(7);
m_seconds_1970++;
g_previousTime = m_seconds_1970;
_g_previousTime = ~g_previousTime;
m_absoluteSecond++;
set_exr(temp_exr);
}
uint32 CRTC::GetAbsoluteSecond()
{
uint32 ret;
unsigned char temp_exr = get_exr();
set_exr(7);
ret = m_absoluteSecond;
set_exr(temp_exr);
return ret;
}
void CRTC::SetTime(uint32 seconds)
{
unsigned char temp_exr = get_exr();
set_exr(7);
m_seconds_1970 = seconds;
set_exr(temp_exr);
}
void CRTC::SetGPSSeconds(uint32 seconds)
{
unsigned char temp_exr = get_exr();
set_exr(7);
m_seconds_1970 = seconds + 315964800L;
set_exr(temp_exr);
}
void CRTC::SetGpsLocal(int32 seconds)
{
unsigned char tmp_exr = get_exr();
set_exr(7);
m_seconds_1970 = seconds + 315964800L;
set_exr(tmp_exr);
}
unsigned long CRTC::GetGPSSeconds()
{
uint32 sec;
unsigned char temp_exr = get_exr();
set_exr(7);
sec = m_seconds_1970;
set_exr(temp_exr);
if (sec < 315964800L) {
return 0L;
}
return (sec - 315964800L);
}
void CRTC::SetComputerSeconds(uint32 seconds)
{
unsigned char temp_exr = get_exr();
set_exr(7);
m_seconds_1970 = seconds;
set_exr(temp_exr);
}
unsigned long CRTC::GetComputerSeconds()
{
uint32 sec;
unsigned char temp_exr = get_exr();
set_exr(7);
sec = m_seconds_1970;
set_exr(temp_exr);
return sec;
}
uint32 CRTC::GetMjd()
{
uint32 cur_time;
uint32 days;
unsigned char temp_exr = get_exr();
set_exr(7);
cur_time = m_seconds_1970;
set_exr(temp_exr);
days = cur_time / 86400L;
return (days + MJD_1_1_1970);
}
void CRTC::GetDateTime(int *year, int *month, int *day, int *hour, int *minute, int *second)
{
uint32 cur_time = m_seconds_1970;
uint32 total_days;
uint32 seconds_in_day;
unsigned char temp_exr = get_exr();
set_exr(7);
cur_time = m_seconds_1970;
set_exr(temp_exr);
seconds_in_day = cur_time % 86400L;
total_days = cur_time / 86400L;
*second = (int)(seconds_in_day % 60L);
seconds_in_day /= 60L;
*minute = (int)(seconds_in_day % 60L);
*hour = (int)(seconds_in_day / 60L);
int cur_year = 1970;
{
int day_in_year;
// Find the year
do {
day_in_year = DaysOfYear(cur_year);
if (total_days >= day_in_year) {
total_days -= day_in_year;
cur_year++;
} else {
break;
}
} while (1);
*year = cur_year;
}
{
// Find month
int cur_month = 1;
int day_in_month;
do {
day_in_month = DaysOfMonth(cur_year, cur_month);
if (total_days >= day_in_month) {
total_days -= day_in_month;
cur_month++;
} else {
break;
}
} while (1);
*month = cur_month;
}
*day = total_days + 1;
}
int CRTC::DaysOfYear(int year)
{
return (IsLeapYear(year) + 365);
}
int CRTC::IsLeapYear(int year)
{
while ((year % 100) == 0) {
year /= 100;
}
if (year % 4) {
return 0;
} else {
return 1;
}
}
int CRTC::DaysOfMonth(int year, int month)
{
static const int days[12] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
if (month == 2) {
return (28 + IsLeapYear(year));
}
return (days[month-1]);
}
int CRTC::SetDateTime(int year, int month, int day, int hour, int minute, int second)
{
uint32 cur_time;
uint32 total_days;
// Year must be between 1970, 2037
if ((year < 1970)||(year > 2037)) return -1;
if ((month < 1) || (month > 12)) return -1;
if (day < 1) return -1;
if (day > DaysOfMonth(year, month)) return -1;
if ((hour < 0) || (hour > 23)) return -1;
if ((minute < 0) || (minute > 59)) return -1;
if ((second < 0) || (second > 59)) return -1;
cur_time = (unsigned long)hour * 3600 + (unsigned long)minute * 60 + second;
total_days = (unsigned long)day - 1;
// Add days in previous month
for (int i = 1; i < month; i++) {
total_days += (unsigned long)DaysOfMonth(year, i);
}
// Add days in previous year
for (i = 1970; i < year; i++) {
total_days += (unsigned long)DaysOfYear(i);
}
cur_time += total_days * 86400L;
SetTime(cur_time);
return 1;
}
#if 0
extern "C" void RTC_TICK(void)
{
g_pRTC->TickOfOneSecond();
}
#endif
extern "C" unsigned long GetGPSSeconds(void)
{
return g_pRTC->GetGPSSeconds();
}
extern "C" void SetGPSSeconds(unsigned long seconds)
{
g_pRTC->SetGPSSeconds(seconds);
}
extern CSci *g_pSci0;
extern CSci *g_pSci1;
// Called by ISR of RTOS tick
EXTERN void RTOS_TICK(void)
{
static int16 cnt = 0;
static uint16 soft = 0;
#if 0
if (TMR0.TCSR.BIT.CMFA)
TMR0.TCSR.BIT.CMFA = 0;
#endif
if (TMR3.TCSR.BIT.CMFA) {
TMR3.TCSR.BIT.CMFA = 0;
}
if (!g_cmx_started) {
// SOFT_DIVISION is 2
if (soft++ & 1) return;
g_systemTicks++;
return;
}
if (g_pSci3 != NULL)
g_pSci3->CheckInput();
if (g_pSci4 != NULL)
g_pSci4->CheckInput();
if (g_pSci1 != NULL)
g_pSci1->CheckInput();
if (g_pSci0 != NULL)
g_pSci0->CheckInput();
// SOFT_DIVISION is 2
if (soft++ & 1) return;
g_systemTicks++;
cnt++;
if ( cnt >= TICK_1SEC) {
// One second
cnt = 0;
#if TIMING_CPU
//CAllProcess::g_pAllProcess->SecondAnnounce(); // Move it to CSecondProcess to be more accurate
#endif
CAllProcess::g_pAllProcess->OsSecondAnnounce(); // One second tick to HLTH
}
K_OS_Tick_Update();
}
EXTERN uint32 GetRawTick(void)
{
uint32 ret;
uint8 tmp_exr;
tmp_exr = get_exr();
set_exr(7);
ret = g_systemTicks;
set_exr(tmp_exr);
return ret;
}
| [
"[email protected]"
] | |
60f71e0d97240b88bea96e194babf4ec3570fade | 0210c351cddbd585438cbc8d355893dfc78968fb | /source/EditArmor.h | 7af7603bb952cfa56f12a3879d0831f5737393d9 | [] | no_license | pbem-games/Atlaclient | d4bbe15b1a54c02b7c481fc5ae013833027d04e3 | afcc4d57824873c416d43ecf23dba38bb0933dfa | refs/heads/master | 2022-02-28T02:45:50.163379 | 2013-11-24T10:12:38 | 2013-11-24T10:12:38 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,638 | h | //---------------------------------------------------------------------------
#ifndef EditArmorH
#define EditArmorH
//---------------------------------------------------------------------------
#include <Classes.hpp>
#include <Controls.hpp>
#include <StdCtrls.hpp>
#include <Forms.hpp>
#include "util.h"
//---------------------------------------------------------------------------
class TfEditArmor : public TForm
{
__published: // IDE-managed Components
TMemo *Memo;
TLabel *Label1;
TComboBox *cbAT;
TCheckBox *cbAss;
TGroupBox *GroupBox1;
TLabel *Label2;
TLabel *Label3;
TLabel *Label4;
TLabel *Label5;
TLabel *Label6;
TLabel *Label7;
TLabel *Label8;
TLabel *Label9;
TEdit *ed1;
TEdit *ed2;
TEdit *ed4;
TEdit *ed3;
TEdit *ed6;
TEdit *ed5;
TEdit *ed8;
TEdit *ed7;
TButton *bnCancel;
TButton *bnOk;
TLabel *Label10;
TEdit *edFrom;
void __fastcall FormCreate(TObject *Sender);
void __fastcall bnOkClick(TObject *Sender);
private: // User declarations
AArmorType *Farm;
bool bNewArm;
public: // User declarations
AnsiString TekItem;
__fastcall TfEditArmor(TComponent* Owner,
AArmorType *arm, AnsiString descr);
};
//---------------------------------------------------------------------------
extern PACKAGE TfEditArmor *fEditArmor;
//---------------------------------------------------------------------------
#endif
| [
"[email protected]"
] | |
1ddb63ac68536532d14f47dbe80c709291a38c06 | 90184bb72202ba4663fb96c6410db804c5dbe574 | /1314. Matrix Block Sum.cpp | a21a89eaa470db67d813f24d13b927c42fd324a1 | [] | no_license | habib302/leetcode-1 | 08da70eea3ab5c59af530c97c8619f1b79de4dde | 32f6ccecd9213edb51824c3214246194ccbc4ccb | refs/heads/master | 2023-08-04T13:28:11.732528 | 2021-09-21T07:45:10 | 2021-09-21T07:45:10 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,639 | cpp |
class Solution {
public:
vector<vector<int>> matrixBlockSum(vector<vector<int>>& mat, int k) {
int rows = mat.size();
vector < vector < int > > ans( rows );
if( rows == 0 ) return ans;
int cols = mat[0].size();
vector < vector < int > > sum( rows , vector < int > ( cols, 0 ) );
for( int row = 0 ; row < rows ; row++ ) {
for( int col = 0 ; col < cols ; col++ ) {
int upperCorner = row - 1 >= 0 && col - 1 >= 0 ? sum[row-1][col-1] : 0;
int up = row - 1 >= 0 ? sum[row-1][col] : 0;
int lft = col - 1 >= 0 ? sum[row][col-1] : 0;
sum[row][col] = ( lft + up - upperCorner ) + mat[row][col];
}
}
for( int row = 0 ; row < rows ; row++ ) {
for( int col = 0 ; col < cols ; col++ ) {
int upperRow = row - k;
int upperCol = col - k;
int lowerRow = row + k >= rows ? rows - 1 : row + k;
int lowerCol = col + k >= cols ? cols - 1 : col + k;
int sumCompleteBox = sum[lowerRow][lowerCol];
int outSideCornerBox = row - k - 1 >= 0 && col - k - 1 >= 0 ? sum[row-k-1][col-k-1] : 0;
int lft = upperCol - 1 >= 0 ? sum[lowerRow][upperCol - 1] : 0 ;
int up = upperRow - 1 >= 0 ? sum[upperRow - 1][lowerCol] : 0 ;
int res = ( sumCompleteBox + outSideCornerBox ) - ( lft + up );
ans[row].push_back( res );
}
}
return ans;
}
};
| [
"[email protected]"
] | |
2e9f87ee03fb30444298b3ad2c7dfa871c57cf10 | 37f7cec960699cfc1755048b8fcdf2fe77a6ca57 | /CCLHBotCommons/src/Services/GameService.cpp | 12ca2d9337100be75ce938209679247b896592a4 | [] | no_license | themarioga/CCLHBot | 3e87977c0bc8c53627e36b3dbe9b9711aeb323af | f9516ed01a77e77c63d0e90061aa674ee7c5b023 | refs/heads/master | 2021-01-19T02:55:05.363525 | 2020-05-16T18:15:23 | 2020-05-16T18:15:23 | 207,660,538 | 5 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,433 | cpp | #include "Services/GameService.h"
#include "Base/Db.h"
void GameService::VoteDelete(int64_t game_id, int64_t player_id) {
try {
//Query
std::shared_ptr<SQLite::Statement> query = Db::Instance()->CreateQuery(
"INSERT INTO gamesxplayers_votedelete (game_id, player_id) VALUES (?, ?)"
);
query->bind(1, game_id);
query->bind(2, player_id);
if (!query->exec()) throw NoResultsException();
} catch (NoResultsException& e) {
throw PlayerAlreadyVoteDeleteException();
} catch (SQLite::Exception& e) {
if (std::string(e.what()).find("UNIQUE constraint failed") != std::string::npos) {
throw PlayerAlreadyVoteDeleteException();
} else {
throw UnexpectedException(e.what());
}
} catch (std::runtime_error& e) {
throw UnexpectedException(e.what());
}
}
int32_t GameService::GetVoteDeletePlayerCount(int64_t game_id) {
try {
//Query
std::shared_ptr<SQLite::Statement> query = Db::Instance()->CreateQuery(
"SELECT count(*) as votes FROM gamesxplayers_votedelete WHERE game_id = ? "
);
query->bind(1, game_id);
if (!query->executeStep()) throw NoResultsException();
return query->getColumn(0);
} catch (NoResultsException& e) {
throw GameNotExistsException();
} catch (SQLite::Exception& e) {
throw UnexpectedException(e.what());
} catch (std::runtime_error& e) {
throw UnexpectedException(e.what());
}
}
void GameService::ClearVoteDelete(int64_t game_id) {
try {
//Query
std::shared_ptr<SQLite::Statement> query = Db::Instance()->CreateQuery("DELETE FROM gamesxplayers_votedelete WHERE game_id = ?");
query->bind(1, game_id);
if (!query->exec()) throw NoResultsException();
} catch (NoResultsException& e) {
//Controlled exception
} catch (SQLite::Exception& e) {
throw UnexpectedException(e.what());
} catch (std::runtime_error& e) {
throw UnexpectedException(e.what());
}
}
Game GameService::GetGameByCreatorID(int64_t user_id) {
try {
//Query
std::shared_ptr<SQLite::Statement> query = Db::Instance()->CreateQuery(
"SELECT rooms.id, rooms.name, rooms.owner_id, rooms.active, "
"games.creator_id, games.message_id, games.status, "
"games.type, games.n_players, games.n_cards_to_win, "
"games.dictionary_id, games.president_id, games.round_number "
"FROM rooms INNER JOIN games ON games.room_id = rooms.id "
"WHERE games.creator_id = ? OR rooms.owner_id = ?"
);
query->bind(1, user_id);
query->bind(2, user_id);
if (!query->executeStep()) throw NoResultsException();
return query->getColumns<Game, 13>();
} catch (SQLite::Exception& e) {
throw UnexpectedException(e.what());
} catch (std::runtime_error& e) {
throw UnexpectedException(e.what());
}
}
std::vector<Game> GameService::GetAllGames() {
try {
std::vector<Game> games;
//Query
std::shared_ptr<SQLite::Statement> query = Db::Instance()->CreateQuery(
"SELECT rooms.id, rooms.name, rooms.owner_id, rooms.active, "
"games.creator_id, games.message_id, games.status, "
"games.type, games.n_players, games.n_cards_to_win, "
"games.dictionary_id, games.president_id, games.round_number "
"FROM rooms INNER JOIN games ON games.room_id = rooms.id"
);
while (query->executeStep()) {
Game game = query->getColumns<Game, 13>();
games.push_back(game);
}
return games;
} catch (SQLite::Exception& e) {
throw UnexpectedException(e.what());
} catch (std::runtime_error& e) {
throw UnexpectedException(e.what());
}
} | [
"[email protected]"
] | |
59a10177e451909a7058382ba8104251d2f068c2 | d7b9fc7f5b7102c2e045256ceea8a31874ff5f0c | /player/ffmpeg/lf/main.cpp | a21d219f1e527e22b5bc8d99442e0f8d115be96e | [] | no_license | kaiyasa/Miner-s-Play | aa04ef302e3549b2d63696d30102c934ca6d270a | 79a7be8af52eb5db50b34c60bd102d2f1e88e640 | refs/heads/master | 2021-01-17T08:29:22.428537 | 2016-07-15T19:09:03 | 2016-07-15T19:09:03 | 3,799,819 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,062 | cpp |
#include <cstdio>
extern "C" {
#include <libavutil/imgutils.h>
#include <libavutil/samplefmt.h>
#include <libavformat/avformat.h>
}
using namespace std;
void show(const char *fname) {
AVFormatContext *fmt_ctx = NULL;
/* open input file, and allocate format context */
if (avformat_open_input(&fmt_ctx, fname, NULL, NULL) < 0) {
fprintf(stderr, "ERROR: cannot open media file: '%s'\n", fname);
exit(1);
}
/* dump input information to stderr */
av_dump_format(fmt_ctx, 0, fname, 0);
int audio_stream_idx = -1;
AVCodecContext *audio_dec_ctx = NULL;
AVStream *audio_stream = NULL;
if (open_codec_context(&audio_stream_idx, fmt_ctx, AVMEDIA_TYPE_AUDIO) >= 0) {
audio_stream = fmt_ctx->streams[audio_stream_idx];
audio_dec_ctx = audio_stream->codec;
}
}
int main(int argc, char **argv) {
/* register all formats and codecs */
av_register_all();
if (argc > 1)
for(auto c = 1; c < argc; ++c)
show(argv[c]);
return 0;
}
| [
"[email protected]"
] |
Subsets and Splits