1.des算法源代码
2.dspace 介绍
3.工业触摸液晶显示器？是统源什么？

des算法源代码

       des.h文件：

       #ifndef CRYPTOPP_DES_H

       #define CRYPTOPP_DES_H

       #include "cryptlib.h"

       #include "misc.h"

       NAMESPACE_BEGIN(CryptoPP)

       class DES : public BlockTransformation

       {

       public:

       DES(const byte *userKey, CipherDir);

       void ProcessBlock(const byte *inBlock, byte * outBlock) const;

       void ProcessBlock(byte * inoutBlock) const

       { DES::ProcessBlock(inoutBlock, inoutBlock);}

       enum { KEYLENGTH=8, BLOCKSIZE=8};

       unsigned int BlockSize() const { return BLOCKSIZE;}

       protected:

       static const word Spbox[8][];

       SecBlock<word> k;

       };

       class DESEncryption : public DES

       {

       public:

       DESEncryption(const byte * userKey)

       : DES (userKey, ENCRYPTION) { }

       };

       class DESDecryption : public DES

       {

       public:

       DESDecryption(const byte * userKey)

       : DES (userKey, DECRYPTION) { }

       };

       class DES_EDE_Encryption : public BlockTransformation

       {

       public:

       DES_EDE_Encryption(const byte * userKey)

       : e(userKey, ENCRYPTION), d(userKey + DES::KEYLENGTH, DECRYPTION) { }

       void ProcessBlock(const byte *inBlock, byte * outBlock) const;

       void ProcessBlock(byte * inoutBlock) const;

       enum { KEYLENGTH=, BLOCKSIZE=8};

       unsigned int BlockSize() const { return BLOCKSIZE;}

       private:

       DES e, d;

       };

       class DES_EDE_Decryption : public BlockTransformation

       {

       public:

       DES_EDE_Decryption(const byte * userKey)

       : d(userKey, DECRYPTION), e(userKey + DES::KEYLENGTH, ENCRYPTION) { }

       void ProcessBlock(const byte *inBlock, byte * outBlock) const;

       void ProcessBlock(byte * inoutBlock) const;

       enum { KEYLENGTH=, BLOCKSIZE=8};

       unsigned int BlockSize() const { return BLOCKSIZE;}

       private:

       DES d, e;

       };

       class TripleDES_Encryption : public BlockTransformation

       {

       public:

       TripleDES_Encryption(const byte * userKey)

       : e1(userKey, ENCRYPTION), d(userKey + DES::KEYLENGTH, DECRYPTION),

       e2(userKey + 2*DES::KEYLENGTH, ENCRYPTION) { }

       void ProcessBlock(const byte *inBlock, byte * outBlock) const;

       void ProcessBlock(byte * inoutBlock) const;

       enum { KEYLENGTH=, BLOCKSIZE=8};

       unsigned int BlockSize() const { return BLOCKSIZE;}

       private:

       DES e1, d, e2;

       };

       class TripleDES_Decryption : public BlockTransformation

       {

       public:

       TripleDES_Decryption(const byte * userKey)

       : d1(userKey + 2*DES::KEYLENGTH, DECRYPTION), e(userKey + DES::KEYLENGTH, ENCRYPTION),

       d2(userKey, DECRYPTION) { }

       void ProcessBlock(const byte *inBlock, byte * outBlock) const;

       void ProcessBlock(byte * inoutBlock) const;

       enum { KEYLENGTH=, BLOCKSIZE=8};

       unsigned int BlockSize() const { return BLOCKSIZE;}

       private:

       DES d1, e, d2;

       };

       NAMESPACE_END

       #endif

       des.cpp文件：

       // des.cpp - modified by Wei Dai from:

       /*

       * This is a major rewrite of my old public domain DES code written

       * circa , which in turn borrowed heavily from Jim Gillogly's

       * public domain code. I pretty much kept my key scheduling code, but

       * the actual encrypt/decrypt routines are taken from from Richard

       * Outerbridge's DES code as printed in Schneier's "Applied Cryptography."

       *

       * This code is in the public domain. I would appreciate bug reports and

       * enhancements.

       *

       * Phil Karn KA9Q, karn@unix.ka9q.ampr.org, August .

       */

       #include "pch.h"

       #include "misc.h"

       #include "des.h"

       NAMESPACE_BEGIN(CryptoPP)

       /* Tables defined in the Data Encryption Standard documents

       * Three of these tables, the initial permutation, the final

       * permutation and the expansion operator, are regular enough that

       * for speed, we hard-code them. They're here for reference only.

       * Also, the S and P boxes are used by a separate program, gensp.c,

       * to build the combined SP box, Spbox[]. They're also here just

       * for reference.

       */

       #ifdef notdef

       /* initial permutation IP */

       static byte ip[] = {

       , , , , , , , 2,

       , , , , , , , 4,

       , , , , , , , 6,

       , , , , , , , 8,

       , , , , , , 9, 1,

       , , , , , , , 3,

       , , , , , , , 5,

       , , , , , , , 7

       };

       /* final permutation IP^-1 */

       static byte fp[] = {

       , 8, , , , , , ,

       , 7, , , , , , ,

       , 6, , , , , , ,

       , 5, , , , , , ,

       , 4, , , , , , ,

       , 3, , , , , , ,

       , 2, , , , , , ,

       , 1, , 9, , , ,

       };

       /* expansion operation matrix */

       static byte ei[] = {

       , 1, 2, 3, 4, 5,

       4, 5, 6, 7, 8, 9,

       8, 9, , , , ,

       , , , , , ,

       , , , , , ,

       , , , , , ,

       , , , , , ,

       , , , , , 1

       };

       /* The (in)famous S-boxes */

       static byte sbox[8][] = {

       /* S1 */

       , 4, , 1, 2, , , 8, 3, , 6, , 5, 9, 0, 7,

       0, , 7, 4, , 2, , 1, , 6, , , 9, 5, 3, 8,

       4, 1, , 8, , 6, 2, , , , 9, 7, 3, , 5, 0,

       , , 8, 2, 4, 9, 1, 7, 5, , 3, , , 0, 6, ,

       /* S2 */

       , 1, 8, , 6, , 3, 4, 9, 7, 2, , , 0, 5, ,

       3, , 4, 7, , 2, 8, , , 0, 1, , 6, 9, , 5,

       0, , 7, , , 4, , 1, 5, 8, , 6, 9, 3, 2, ,

       , 8, , 1, 3, , 4, 2, , 6, 7, , 0, 5, , 9,

       /* S3 */

       , 0, 9, , 6, 3, , 5, 1, , , 7, , 4, 2, 8,

       , 7, 0, 9, 3, 4, 6, , 2, 8, 5, , , , , 1,

       , 6, 4, 9, 8, , 3, 0, , 1, 2, , 5, , , 7,

       1, , , 0, 6, 9, 8, 7, 4, , , 3, , 5, 2, ,

       /* S4 */

       7, , , 3, 0, 6, 9, , 1, 2, 8, 5, , , 4, ,

       , 8, , 5, 6, , 0, 3, 4, 7, 2, , 1, , , 9,

       , 6, 9, 0, , , 7, , , 1, 3, , 5, 2, 8, 4,

       3, , 0, 6, , 1, , 8, 9, 4, 5, , , 7, 2, ,

       /* S5 */

       2, , 4, 1, 7, , , 6, 8, 5, 3, , , 0, , 9,

       , , 2, , 4, 7, , 1, 5, 0, , , 3, 9, 8, 6,

       4, 2, 1, , , , 7, 8, , 9, , 5, 6, 3, 0, ,

       , 8, , 7, 1, , 2, , 6, , 0, 9, , 4, 5, 3,

       /* S6 */

       , 1, , , 9, 2, 6, 8, 0, , 3, 4, , 7, 5, ,

       , , 4, 2, 7, , 9, 5, 6, 1, , , 0, , 3, 8,

       9, , , 5, 2, 8, , 3, 7, 0, 4, , 1, , , 6,

       4, 3, 2, , 9, 5, , , , , 1, 7, 6, 0, 8, ,

       /* S7 */

       4, , 2, , , 0, 8, , 3, , 9, 7, 5, , 6, 1,

       , 0, , 7, 4, 9, 1, , , 3, 5, , 2, , 8, 6,

       1, 4, , , , 3, 7, , , , 6, 8, 0, 5, 9, 2,

       6, , , 8, 1, 4, , 7, 9, 5, 0, , , 2, 3, ,

       /* S8 */

       , 2, 8, 4, 6, , , 1, , 9, 3, , 5, 0, , 7,

       1, , , 8, , 3, 7, 4, , 5, 6, , 0, , 9, 2,

       7, , 4, 1, 9, , , 2, 0, 6, , , , 3, 5, 8,

       2, 1, , 7, 4, , 8, , , , 9, 0, 3, 5, 6,

       };

       /* -bit permutation function P used on the output of the S-boxes */

       static byte pi[] = {

       , 7, , ,

       , , , ,

       1, , , ,

       5, , , ,

       2, 8, , ,

       , , 3, 9,

       , , , 6,

       , , 4,

       };

       #endif

       /* permuted choice table (key) */

       static const byte pc1[] = {

       , , , , , , 9,

       1, , , , , , ,

       , 2, , , , , ,

       , , 3, , , , ,

       , , , , , , ,

       7, , , , , , ,

       , 6, , , , , ,

       , , 5, , , , 4

       };

       /* number left rotations of pc1 */

       static const byte totrot[] = {

       1,2,4,6,8,,,,,,,,,,,

       };

       /* permuted choice key (table) */

       static const byte pc2[] = {

       , , , , 1, 5,

       3, , , 6, , ,

       , , , 4, , 8,

       , 7, , , , 2,

       , , , , , ,

       , , , , , ,

       , , , , , ,

       , , , , ,

       };

       /* End of DES-defined tables */

       /* bit 0 is left-most in byte */

       static const int bytebit[] = {

       ,,,,,,,

       };

       /* Set key (initialize key schedule array) */

       DES::DES(const byte *key, CipherDir dir)

       : k()

       {

       SecByteBlock buffer(++8);

       byte *const pc1m=buffer; /* place to modify pc1 into */

       byte *const pcr=pc1m+; /* place to rotate pc1 into */

       byte *const ks=pcr+;

       register int i,j,l;

       int m;

       for (j=0; j<; j++) { /* convert pc1 to bits of key */

       l=pc1[j]-1; /* integer bit location */

       m = l & ; /* find bit */

       pc1m[j]=(key[l>>3] & /* find which key byte l is in */

       bytebit[m]) /* and which bit of that byte */

1 : 0; /* and store 1-bit result */

       }

       for (i=0; i<; i++) { /* key chunk for each iteration */

       memset(ks,0,8); /* Clear key schedule */

       for (j=0; j<; j++) /* rotate pc1 the right amount */

       pcr[j] = pc1m[(l=j+totrot[i])<(j<? : ) ? l: l-];

       /* rotate left and right halves independently */

       for (j=0; j<; j++){ /* select bits individually */

       /* check bit that goes to ks[j] */

       if (pcr[pc2[j]-1]){

       /* mask it in if it's there */

       l= j % 6;

       ks[j/6] |= bytebit[l] >> 2;

       }

       }

       /* Now convert to odd/even interleaved form for use in F */

       k[2*i] = ((word)ks[0] << )

       | ((word)ks[2] << )

       | ((word)ks[4] << 8)

       | ((word)ks[6]);

       k[2*i+1] = ((word)ks[1] << )

       | ((word)ks[3] << )

       | ((word)ks[5] << 8)

       | ((word)ks[7]);

       }

       if (dir==DECRYPTION) // reverse key schedule order

       for (i=0; i<; i+=2)

       {

       std::swap(k[i], k[-2-i]);

       std::swap(k[i+1], k[-1-i]);

       }

       }

       /* End of C code common to both versions */

       /* C code only in portable version */

       // Richard Outerbridge's initial permutation algorithm

       /*

       inline void IPERM(word &left, word &right)

       {

       word work;

       work = ((left >> 4) ^ right) & 0x0f0f0f0f;

       right ^= work;

       left ^= work << 4;

       work = ((left >> ) ^ right) & 0xffff;

       right ^= work;

       left ^= work << ;

       work = ((right >> 2) ^ left) & 0x;

       left ^= work;

       right ^= (work << 2);

       work = ((right >> 8) ^ left) & 0xffff;

       left ^= work;

       right ^= (work << 8);

       right = rotl(right, 1);

       work = (left ^ right) & 0xaaaaaaaa;

       left ^= work;

       right ^= work;

       left = rotl(left, 1);

       }

       inline void FPERM(word &left, word &right)

       {

       word work;

       right = rotr(right, 1);

       work = (left ^ right) & 0xaaaaaaaa;

       left ^= work;

       right ^= work;

       left = rotr(left, 1);

       work = ((left >> 8) ^ right) & 0xffff;

       right ^= work;

       left ^= work << 8;

       work = ((left >> 2) ^ right) & 0x;

       right ^= work;

       left ^= work << 2;

       work = ((right >> ) ^ left) & 0xffff;

       left ^= work;

       right ^= work << ;

       work = ((right >> 4) ^ left) & 0x0f0f0f0f;

       left ^= work;

       right ^= work << 4;

       }

       */

       // Wei Dai's modification to Richard Outerbridge's initial permutation

       // algorithm, this one is faster if you have access to rotate instructions

       // (like in MSVC)

       inline void IPERM(word &left, word &right)

       {

       word work;

       right = rotl(right, 4U);

       work = (left ^ right) & 0xf0f0f0f0;

       left ^= work;

       right = rotr(right^work, U);

       work = (left ^ right) & 0xffff;

       left ^= work;

       right = rotr(right^work, U);

       work = (left ^ right) & 0x;

       left ^= work;

       right = rotr(right^work, 6U);

       work = (left ^ right) & 0xffff;

       left ^= work;

       right = rotl(right^work, 9U);

       work = (left ^ right) & 0xaaaaaaaa;

       left = rotl(left^work, 1U);

       right ^= work;

       }

       inline void FPERM(word &left, word &right)

       {

       word work;

       right = rotr(right, 1U);

       work = (left ^ right) & 0xaaaaaaaa;

       right ^= work;

       left = rotr(left^work, 9U);

       work = (left ^ right) & 0xffff;

       right ^= work;

       left = rotl(left^work, 6U);

       work = (left ^ right) & 0x;

       right ^= work;

       left = rotl(left^work, U);

       work = (left ^ right) & 0xffff;

       right ^= work;

       left = rotl(left^work, U);

       work = (left ^ right) & 0xf0f0f0f0;

       right ^= work;

       left = rotr(left^work, 4U);

       }

       // Encrypt or decrypt a block of data in ECB mode

       void DES::ProcessBlock(const byte *inBlock, byte * outBlock) const

       {

       word l,r,work;

       #ifdef IS_LITTLE_ENDIAN

       l = byteReverse(*(word *)inBlock);

       r = byteReverse(*(word *)(inBlock+4));

       #else

       l = *(word *)inBlock;

       r = *(word *)(inBlock+4);

       #endif

       IPERM(l,r);

       const word *kptr=k;

       for (unsigned i=0; i<8; i++)

       {

       work = rotr(r, 4U) ^ kptr[4*i+0];

       l ^= Spbox[6][(work) & 0x3f]

       ^ Spbox[4][(work >> 8) & 0x3f]

       ^ Spbox[2][(work >> ) & 0x3f]

       ^ Spbox[0][(work >> ) & 0x3f];

       work = r ^ kptr[4*i+1];

       l ^= Spbox[7][(work) & 0x3f]

       ^ Spbox[5][(work >> 8) & 0x3f]

       ^ Spbox[3][(work >> ) & 0x3f]

       ^ Spbox[1][(work >> ) & 0x3f];

       work = rotr(l, 4U) ^ kptr[4*i+2];

       r ^= Spbox[6][(work) & 0x3f]

       ^ Spbox[4][(work >> 8) & 0x3f]

       ^ Spbox[2][(work >> ) & 0x3f]

       ^ Spbox[0][(work >> ) & 0x3f];

       work = l ^ kptr[4*i+3];

       r ^= Spbox[7][(work) & 0x3f]

       ^ Spbox[5][(work >> 8) & 0x3f]

       ^ Spbox[3][(work >> ) & 0x3f]

       ^ Spbox[1][(work >> ) & 0x3f];

       }

       FPERM(l,r);

       #ifdef IS_LITTLE_ENDIAN

       *(word *)outBlock = byteReverse(r);

       *(word *)(outBlock+4) = byteReverse(l);

       #else

       *(word *)outBlock = r;

       *(word *)(outBlock+4) = l;

       #endif

       }

       void DES_EDE_Encryption::ProcessBlock(byte *inoutBlock) const

       {

       e.ProcessBlock(inoutBlock);

       d.ProcessBlock(inoutBlock);

       e.ProcessBlock(inoutBlock);

       }

       void DES_EDE_Encryption::ProcessBlock(const byte *inBlock, byte *outBlock) const

       {

       e.ProcessBlock(inBlock, outBlock);

       d.ProcessBlock(outBlock);

       e.ProcessBlock(outBlock);

       }

       void DES_EDE_Decryption::ProcessBlock(byte *inoutBlock) const

       {

       d.ProcessBlock(inoutBlock);

       e.ProcessBlock(inoutBlock);

       d.ProcessBlock(inoutBlock);

       }

       void DES_EDE_Decryption::ProcessBlock(const byte *inBlock, byte *outBlock) const

       {

       d.ProcessBlock(inBlock, outBlock);

       e.ProcessBlock(outBlock);

       d.ProcessBlock(outBlock);

       }

       void TripleDES_Encryption::ProcessBlock(byte *inoutBlock) const

       {

       e1.ProcessBlock(inoutBlock);

       d.ProcessBlock(inoutBlock);

       e2.ProcessBlock(inoutBlock);

       }

       void TripleDES_Encryption::ProcessBlock(const byte *inBlock, byte *outBlock) const

       {

       e1.ProcessBlock(inBlock, outBlock);

       d.ProcessBlock(outBlock);

       e2.ProcessBlock(outBlock);

       }

       void TripleDES_Decryption::ProcessBlock(byte *inoutBlock) const

       {

       d1.ProcessBlock(inoutBlock);

       e.ProcessBlock(inoutBlock);

       d2.ProcessBlock(inoutBlock);

       }

       void TripleDES_Decryption::ProcessBlock(const byte *inBlock, byte *outBlock) const

       {

       d1.ProcessBlock(inBlock, outBlock);

       e.ProcessBlock(outBlock);

       d2.ProcessBlock(outBlock);

       }

       NAMESPACE_END

dspace 介绍

       数字资产管理系统DSpace简介

       1 背景

       1.1信息多元化并海量增长

       随着社会的进步和科学技术的发展，人们在科研、统源生产和实践中不断产生出新的统源信息。这些信息的统源增长表现在几个方面：信息数量呈指数级的增长，其中数字资 源每年以%－%的统源速度增长；信息载体不断增多，尤其以网络为载体的统源切割image源码信息；信息格式层出为穷，大体上可以分为文本型、统源数字型、统源型、统源多媒体等 等。统源随着越来越多的统源信息资源的出现，如何创建一个稳定的统源环境来长期保存和获得这些信息是一个重要问题。

       1.2信息供应链改变与图书馆职能改变

       传统的统源信息供应链模式是作者—>出版机构—>图书馆—>读者，随着计算机技术，统源特别是统源网络通讯技术的发展，传统的信息供应链模式已 经完全被打破。作者可以把稿件发给出版机构，由出版机构将其出版发行，另一方面，作者也可以把稿件或相关资料发到网络上，在网络上进行传播。读者可以绕过 图书馆从网络上通过信息服务门户或搜索引擎工具找到所需要的信息。信息供应与信息服务呈现多元化，信息获取也呈现多途径的方式。

       传统图书馆职能也因此而改变，未来的数字图书馆功能之一，要实现以分布式的网络和计算环境为技术支持和应用基础，对海量的、不同类型的信息资源进行制 作、组织、存储、发布和检索，rlgg云验证源码实现读者之间、读者和图书馆管理人员之间的多维和实时沟通。在新的运行环境中，信息活动将从原来的单向度转入多向度，读者可 以自己实现信息的提交、交换和利用，数字图书馆将进一步为整个校园服务，成为校园资源中心。数字图书馆为此将推行新的服务机制和模式。

       1.3信息活动中的利益博弈

       以学术期刊定购为例。目前各图书馆面对两个事实：由于学术期刊的出版受到少数营利出版社的垄断，不断调涨期刊的订费，迫使大学图书馆不得不删订期刊的 种数或减少图书的购置。根据美国研究图书馆学会（ARL-Association of Research Libraries）的调查，从年到年，美国的研究图书馆期刊经费增加了%，但是订购的期刊种数却只增加9%，而购买图书的种数则 下降5%。图书馆供应研究的资源相对减少，其结果将连带影响研究及教学的品质。

       另一方面，学者辛勤努力的研究成果发表时出版社却向学者按页索费（page charge），当学者需要参考利用期刊时，图书馆却需要再付大笔经费订阅。图书馆需要发展和支持通过开放获取（Open Access）模型发表作品的机制，并向学者、社会提供这种机制。

       1.4信息需求与信息行为改变

       信息的多元化发展，信息用户的有用信息也将分布在不同的信息类型中，在获取信息时，信息用户总希望能得到“一站式服务”，截屏app源码即通过一个检索平台或门户， 以最少的操作得到所需要的全部有用信息。为此信息服务部门需要提供存储不同格式、不同类型的信息资源，并提供能有效组织、检索、利用这些资源的信息管理系 统。

       针对以上的各种问题，不同的研究机构、组织提出了不同的解决方案，并相应地开发了不同的应用系统。例如：

       Eprints（由英国南安普敦大学（university of Southampton）开发）；

       Dspace（由MIT和HP联合开发）；

       Fedora（由Univ. of Virginia and Cornell开发）；

       GreenStone（由Univ. of Waikato，Witten&Bainbridge开发）。

       其中，DSpace系统以其高度的灵活性、可用性和可自定义性和开放源代码，受各高校（包括英国剑桥大学、加拿大多伦多大学和美国康奈尔大学、哥伦比 亚大学等）和研究机构的青睐和推崇。现在，全球许多研究机构都用DSpace系统来应对各种不同的数字化文献的需求，如机构知识库 （Institutional Repositories，IRs）、学习对象库（Learning Object Repositories ，LORs）、电子化主题（eTheses）、电子化记录管理（Electronic Records Management，ERM）、数字化保存（Digital Preservation）、出版（Publishing）等等。在此对DSpace系统作一个简单介绍。ai 模拟拳击源码

       2 DSpace系统简介

       DSpace（数字空间）系统是由美国麻省理工学院图书馆（MIT Libraries）和美国惠普公司实验室（Hewlett-Packard Labs）合作经过两年多的努力并于年月开始投入使用的，以内容管理发布为设计目标，遵循BSD协议的开放源代码数字存储系统。该系统可以收 集、存储、索引、保存和重新发布任何数字格式、层次结构的永久标识符研究数据。

       DSpace是一个专门的数字资产（Digital assets）管理系统，它管理和发布由数字文件或“位流”（bitstreams）组成的数字条目（item），并且允许创建、索引和搜索相关的元数据以便定位和存取该条目。它包括的基本概念主要有：

       数字空间群（DSpace communite）：数字空间是针对数字材料的长期保存而设计的。数字材料来源于不同的组群，比如大学的院系、实验室，图书馆的采访、编目等部门，这些依据不同的授权完成不同任务的组群称作数字空间群。

       1）电子用户（e-people）：DSpace的用户可能是教师、学生，也可能只是一些计算机系统，因此DSpace把用户称作“E人”。

       2）工作流（workflow）：DSpace的运作方式，数字材料和元数据在被接受之前经过事先设定的流转审核的步骤；

       3）信息订阅（subscription）：用户可以向DSpace发送订阅请求，以便在新材料到来时收到带有内容提要的Email提示。

       2.2 DSpace系统功能特点

       其特点可以归结为三个要点：基于存储的资产管理；以事件触发构建的工作流机制；以分级权限控制的管理体系；

       2.2.1基于存储的资产管理

       DSpace首先是基于存储管理的，它提供对所有数字格式的支持，比如文档、书籍、数据库、软件源预览源码计算机程序、虚拟和仿真模型、多媒体出版物和学习对象等等。另一方面，对于印刷型文献，DSpace也可以通过元数据进行存储管理，利用URL和馆藏地点来区分文献服务的方式。

       Dspace支持两种存储模式：“位”存储（bit preservation）和功能存储（functional preservation）。位存储保证提交的数字材料没有任何改变，即每一位（bit）均保持原样，在多年以后仍然可以将文件复原出来。功能存储的实现 是通过随着时间的变化改变存储内容的格式，以保证当旧有格式淘汰后，数字材料还能够被随时调用（可浏览、可运行、可检索……）。显而易见，功能存储是理想 的存储状态，但需要更多的经费支持。为此，Dspace对于文件格式定义了三个层次：支持的格式、知道的格式和不支持的格式。些文件格式很容易向通用的格 式转化（像TIFF图像或XML文档），而有些格式会由于专利等原因很难实现功能存储。对于上述的所有三个层次，DSpace建议在经费允许的情况下同时 进行“位”和“功能”存储，以便一旦时间证明哪种格式可以更有效地呈现素材时，“数字考古学家”能够获得最初的原料。

       2.2.2以事件触发构建的工作流机制

       DSpace的运作是以事件触发的机制来实现的。谁可以存储材料，怎样存储，谁可以利用存储的材料，谁负责管理？这一系列问题在可定制的管理策略下完全由事件触发来解决。

       在DSpace中有很多的数字空间群，对于内部工作部门（数字空间群），通常，所有工作人员都设定为“提交者”（submitters），而其中的一 部分人又被设定为“审核者”（reviewers），负责人则设定为终审者（coordinator）。每个数字空间群中都存在着“提交者”、“审核者” 等等的角色。这些角色可能指派给很多人，组成角色群，或称“电子工作组（e-person group）”。 任何一个对系统的请求，从检索、浏览到材料提交，都会触发不同的工作流，并进入相应的“任务池（Task pool）”。经过审核、元数据编辑和终审等等环节最终进入DSpace。而该工作流涉及的每一个步骤的电子工作组，都会因为自己的角色而获得通知，使相 应的电子用户可以进入个人数字空间（Individual DSpace）来完成任务。

       典型的事件如新书采购：书商（用户）的图书馆（DSpace）提交书目，新书通告被放入采访部（acquisition数字空间群）的“任务池”，处 于采访数字空间群的专业人员可以从“任务池”中获取书目进行审核，（相应的书目将同时被移除，以免重复相同的工作流。）如果审核通过，系统产生订购单。如 果是即时生效的数字资源，这一事件将触发DSpace的元数据编辑工作流。如果审核不通过，用户将得到附有审核人员意见的通知书。示意如下：

       对于外部数字空间群，匿名用户可以通过WEB访问进行检索和浏览，授权用户则可以将自己的材料提交DSpace，触发馆藏接收工作流。比如教师的课 件、博士的学位论文，这些数字文献本来就是数字图书馆的馆藏来源，通过DSpace的工作流经过专业馆员的审核和元数据编辑，很方便地进入馆藏。另外，作 为数字图书馆功能的拓展，用户还可以在授权的个人数字空间中临时或永久存放数字材料。

       2.2.3以分级权限控制的管理体系

       如上所述，数字空间群拥有不同的电子工作组，而不同的组拥有不同的权限。某些DSpace的功能，比如检索、浏览等可以是匿名的，但是如提交、订阅以 及管理等功能则需要经过用户认证。DSpace提倡“电子用户”（e-people）的概念，每个电子用户需要向DSpace提供如下信息：

       E-mail 地址

       姓名

       认证信息，比如密码

       订阅专题列表

       DSpace有一个可变的认证系统，它采用的是“缺省否定（default deny）”的策略，比如，一个电子用户对某个元数据具有“读”权限，但他未必就拥有对此元数据指向的材料的“读”权限。

       3 DSpace的优点与不足

       3.1开放源代码

       DSpace系统是一个开放源代码的软件平台，可以从其网站上免费下载，可以自由使用、复制和修改。其所使用的第三方软件也是开放的源代码，如PostgreSQL、JDK、Apache等。DSpace主要代码均为Java编写，可以运行于所有UNIX系统。

       3.2 修改和扩展功能容易

       DSpace提供了几个支持API接口的内置程序，可以通过它简化和加速数字馆藏的开发，在一定程度上为系统提供了扩展和修改的能力。另外，由于Java虚拟机是由HTML和部分嵌入的Java代码组成的，基本上不需要触动其核心的代码就可以方便地修改它。

       3.3 DSpace系统能接受几乎所有的文件类型

       DSpace可以接受的电子化材料包括：

       论文与预印稿（Articles and preprints）

       技术报告（Technical reports）

       雇用证书（Working papers）

       会议论文（Conference papers）

       电子论题（E-theses）

       数据集，包括统计数据、地理信息数据、数学等等（Datasets: statistical, geospatial, matlab, etc.）

       图像，包括可视化图像、科学图表等（Images: visual, scientific, etc.）

       声频文件（Audio files）

       视频文件（Video files）

       学习对象（Learning objects）

       重定格式后的数字图书馆馆藏（Reformatted digital library collections）

       DSpace可以存储、管理和发布任何已经和未经出版的本地馆藏，保证印刷和数字文献的统一索引和定位。

       3.4检索功能强大

       DSpace的目标就是提供尽量多的检索特色。DSpace的索引和检索模型有一个API接口，允许非常方便地索引新内容，重建索引以及在指定范围内 检索。这个API来自免费的Java搜索引擎——Lucene 。Lucene支持字段检索、停词（stop words）、词干（stemming）以及不重建索引增加新的索引内容的能力。

       3.5界面简洁友好

       所有的DSpace用户界面都是基于WEB的，并且包含一系列的界面：用户提交界面、搜索界面、系统管理界面以及提交审核的各种界面。利用Java虚拟机和Java服务器技术，DSpace允许用户通过浏览器访问系统，这使DSpace的使用和管理都十分方便。

       3.6建立DSpace联盟

       在虚拟存储技术的支持下，利用DSpace联盟，还可以实现虚拟馆藏：联盟的馆藏对于用户完全透明，用户通过WEB界面访问元数据，并发送资源请求。 DSpace可以根据标准协议进入不同院校的系统，如康奈尔大学的arXiv ，通过本地的存储过程自动获取有关的文档备份。用户只需点击锁定（located）的条目，它就会被下载到WEB浏览器中。如果是一种WEB支持（Web -native）的格式，它就会立刻显示在浏览器中；否则它就被存储在用户的计算机上，象Excel数据表或者CAD文件，需要以特定的程序来打开它。

       当然DSpace也存在不足之处，当要对DSpace 系统扩展功能进行比较复杂的修改时，需要修改系统的核心组件，这给系统的数据库结构和兼容方面带来影响；另外，DSpace系统不支持原始内容的创建，但 可以以工作流方式捕获任何支持主动文档开放协议(Open Archives Initiative)的数字资源和元数据。

工业触摸液晶显示器？是什么？

       工业触摸液晶显示器必须要知道的就是这个原理。

       首先需要知道的就是这个工业显示器：

       工业显示器就是应用在工业控制过程或设备的显示器。它与民用或商用的显示器的主要区别是外壳设计一般采用全钢设计，面板分为普通铁板、不锈铁、不锈钢、铝面板等不同材质，防尘、防震的特殊设计，采用工业级的液晶显示屏，在对环境要求较高的情况下，考虑采用宽温（－至度）的液晶显示屏,目前仅国外少数大厂生产这类显示屏,价格较贵。工业显示器的防护等级用IP**表示，前一位是防尘等级，后一位是防水等级。防尘等级最高为6，防水最高为8 。

       能够提供触觉的触摸接口系统依赖于执行器产生触感。执行器和控制技术的发展使得目前的执行器能够支持各种从很小到很大的触摸面板和触摸屏上的触摸反馈，产品范围覆盖了从手机到宽屏触摸监视器等各种产品。另外，支持触觉系统所需的处理器负荷相当小，触摸输入技术事实上已经非常普及，机电解决方案也都是现成的。这就是工业液晶触摸显示器了 。

       由《宝莱纳》提供，望采纳哦！

       Tel：O-Z5II