`

HBase-HFile的读写操作

 
阅读更多

 

写入数据:

 

public class TestWrit {
	private static Configuration cfg = new Configuration();
	private static final int BLOCK_INDEX_SIZE = 60;
	private static final int BLOOM_BLOCK_INDEX_SIZE = 10;
	public TestWrit() {
		cfg.setInt("hfile.index.block.max.size", BLOCK_INDEX_SIZE);
		cfg.setInt("io.storefile.bloom.block.size", BLOOM_BLOCK_INDEX_SIZE);
		//cfg.setBoolean("hbase.regionserver.checksum.verify", true);
	}
	
	public static void main(String[] args) throws IOException {
	}
	
	public void test() throws IOException {
		//指定写入的路径
		Path path = new Path("/data0/hbase/test/myhfile");		
		FileSystem fs = FileSystem.get(cfg);
		CacheConfig config = new CacheConfig(cfg);
		FSDataOutputStream fsdos = fs.create(path);
		//MyDataOutputStream mdos = new MyDataOutputStream(fsdos);
		//fsdos = new FSDataOutputStream(mdos);
		
		//创建压缩算法,文件块编码,比较器
		//HFile默认的比较器是字典排序的,也可以生成一个自定义的比较器,但必须继承KeyComparator
		Algorithm algorithm = Algorithm.GZ;
		HFileDataBlockEncoder encoder = new HFileDataBlockEncoderImpl(DataBlockEncoding.DIFF);
		KeyComparator comparator = new KeyComparator();
		ChecksumType check = ChecksumType.CRC32;
	
		//创建HFile写实现类,指定写入的数据块大小,多少字节生成一个checksum
		int blockSize = 100;
		int checkPerBytes = 16384;
		HFileWriterV2 v2 = new HFileWriterV2(cfg, config, fs, path, fsdos, blockSize, algorithm, 
				encoder, comparator, check, checkPerBytes, true);
	
	/**
	 * HFile默认的比较器是字典排序的,所以插入的key也必须是字典排序,如果不想按照字典排序,
	 * 这里使用红黑树保证key的有序性
		String keyPrefix = new String("key");
		TreeSet<String> set = new TreeSet<String>();
		int len = 100;
		for(int i=1;i<=len;i++) {
			set.add(""+i);
		}
		for(String key:set) {
			String generatorKey = keyPrefix+key;
			v2.append( generator(generatorKey,"c","",System.currentTimeMillis(),VALUES) );
		}
	*/
		
		//创建两个布隆过滤器,指定最大的key数为5
		int maxKey = 5;
		BloomFilterWriter bw = BloomFilterFactory.createGeneralBloomAtWrite(cfg, config, BloomType.ROW, maxKey, v2);
		BloomFilterWriter bw2 = BloomFilterFactory.createDeleteBloomAtWrite(cfg, config, maxKey, v2);
	
		//生成KeyValue,插入到HFile中,并保存到布隆过滤器中
		KeyValue kv = generator("key111111111111111111111111","value","f",System.currentTimeMillis(),new byte[]{'2'});
		addToHFileWirterAndBloomFile(kv,v2,bw,bw2);
		
		kv = generator("key222222222222222222222222","value","f",System.currentTimeMillis(),new byte[]{'2'});
		addToHFileWirterAndBloomFile(kv,v2,bw,bw2);
		
		kv = generator("key333333333333333333333333","value","f",System.currentTimeMillis(),new byte[]{'2'});
		addToHFileWirterAndBloomFile(kv,v2,bw,bw2);
		
		//生成meta块,布隆过滤器块,删除的布隆过滤器块
		//自定义文件信息块的key-value
		//布隆过滤器加入到HFile.Writer时会判断里面是否有数据,所以要先将key插入到布隆过滤器中,再加入到
		//Writerv2中
		v2.addGeneralBloomFilter(bw);
		v2.addDeleteFamilyBloomFilter(bw2);
		v2.appendMetaBlock("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", new MyWritable());
		v2.appendFileInfo(Bytes.toBytes("mykey"), Bytes.toBytes("myvalue"));
		v2.close();
	}
	
	/**
	 * 插入一个KeyValue到HFile中,同时将这个key保存到布隆过滤器中
	 */
	public void addToHFileWirterAndBloomFile(KeyValue kv, HFileWriterV2 v2, BloomFilterWriter bw, BloomFilterWriter bw2) 
	throws IOException {
		v2.append( kv );
		byte[] buf = bw.createBloomKey(kv.getBuffer(),
                kv.getRowOffset(), kv.getRowLength(), kv.getBuffer(),
                kv.getQualifierOffset(), kv.getQualifierLength());
		bw.add(buf, 0, buf.length);
		bw2.add(buf, 0, buf.length);
	
	}
	
	/**
	 * 生成KeyValue
	 */
	public KeyValue generator(String key,String column,String qualifier,long timestamp,byte[] value) {
		byte[] keyBytes = Bytes.toBytes(key);
		byte[] familyBytes = Bytes.toBytes(column);
		byte[] qualifierBytes = Bytes.toBytes(qualifier);
		Type type = Type.Put;
		byte[] valueBytes = value;
		KeyValue kv = new KeyValue(keyBytes, 0, keyBytes.length, familyBytes, 0, familyBytes.length, 
				qualifierBytes, 0, qualifierBytes.length, timestamp, type, valueBytes, 0, valueBytes.length);		
		return kv;
	}
}

 

 

写入到磁盘时的内存dump:


 

读取操作:

public class TestReader {

	public static String FILE_PATH = "/data0/hbase/test/myhfile";
	public Configuration cfg = new Configuration();
	private FSReader fsBlockReader;
	/**
	 * 二级索引长度
	 */
	private static final int SECONDARY_INDEX_ENTRY_OVERHEAD = Bytes.SIZEOF_INT + Bytes.SIZEOF_LONG;

	public static void main(String[] args) throws Exception {
		TestReader t = new TestReader();
		t.readBloom();
	}

	/**
	 * 解析布隆过滤器
	 */
	public void readBloom() throws IOException {
		// 创建读取路径,本地文件系统,两个读取流
		Path path = new Path(FILE_PATH);
		FileSystem fs = FileSystem.getLocal(cfg);
		CacheConfig config = new CacheConfig(cfg);

		// 由HFile创建出Reader实现类
		Reader reader = HFile.createReader(fs, path, config);

		// 创建通用布隆过滤器
		DataInput bloomMeta = reader.getGeneralBloomFilterMetadata();
		BloomFilter bloomFilter = null;
		if (bloomMeta != null) {
			bloomFilter = BloomFilterFactory.createFromMeta(bloomMeta, reader);
			System.out.println(bloomFilter);
		}

		//创建删除的布隆过滤器
		bloomMeta = reader.getDeleteBloomFilterMetadata();
		bloomFilter = null;
		if (bloomMeta != null) {
			bloomFilter = BloomFilterFactory.createFromMeta(bloomMeta, reader);
			System.out.println(bloomFilter);
		}
		
		//meta的读取实现在  HFileReaderV2#getMetaBlock()中
	}

	/**
	 * 使用Scanner读取数据块内容
	 */
	@SuppressWarnings("unchecked")
	public void readScan() throws IOException, SecurityException,
			NoSuchMethodException, IllegalArgumentException,
			IllegalAccessException, InvocationTargetException {
		// 创建读取路径,本地文件系统,两个读取流
		Path path = new Path(FILE_PATH);
		FileSystem fs = FileSystem.getLocal(cfg);
		CacheConfig config = new CacheConfig(cfg);
		FSDataInputStream fsdis = fs.open(path);
		FSDataInputStream fsdisNoFsChecksum = fsdis;
		HFileSystem hfs = new HFileSystem(fs);
		long size = fs.getFileStatus(path).getLen();

		// 由读FS读取流,文件长度,就可以读取到尾文件块
		FixedFileTrailer trailer = FixedFileTrailer.readFromStream(fsdis, size);

		// 根据尾文件块,和其他相关信息,创建HFile.Reader实现
		HFileReaderV2 v2 = new HFileReaderV2(path, trailer, fsdis,
				fsdisNoFsChecksum, size, true, config, DataBlockEncoding.NONE,
				hfs);
		System.out.println(v2);

		// 读取FileInfo中的内容
		Method method = v2.getClass().getMethod("loadFileInfo", new Class[] {});
		Map<byte[], byte[]> fileInfo = (Map<byte[], byte[]>) method.invoke(v2,
				new Object[] {});
		Iterator<Entry<byte[], byte[]>> iter = fileInfo.entrySet().iterator();
		while (iter.hasNext()) {
			Entry<byte[], byte[]> entry = iter.next();
			System.out.println(Bytes.toString(entry.getKey()) + " = "
					+ Bytes.toShort(entry.getValue()));
		}

		// 由Reader实现创建扫描器Scanner,负责读取数据块
		// 并遍历所有的数据块中的KeyValue
		HFileScanner scanner = v2.getScanner(false, false);
		scanner.seekTo();
		System.out.println(scanner.getKeyValue());

		KeyValue kv = scanner.getKeyValue();
		while (scanner.next()) {
			kv = scanner.getKeyValue();
			System.out.println(kv);
		}
		v2.close();

	}

	/**
	 * 解析HFile中的数据索引
	 */
	@SuppressWarnings({ "unused", "unchecked" })
	public void readIndex() throws Exception {
		// 创建读取路径,本地文件系统,两个读取流
		// 由读FS读取流,文件长度,就可以读取到尾文件块
		Path path = new Path(FILE_PATH);
		FileSystem fs = FileSystem.getLocal(cfg);
		CacheConfig config = new CacheConfig(cfg);
		FSDataInputStream fsdis = fs.open(path);
		FSDataInputStream fsdisNoFsChecksum = fsdis;
		HFileSystem hfs = new HFileSystem(fs);
		long size = fs.getFileStatus(path).getLen();
		FixedFileTrailer trailer = FixedFileTrailer.readFromStream(fsdis, size);

		// 下面创建的一些类,在Reader实现类的构造函数中也可以找到,创建具体文件读取实现FSReader
		// 由于这个类没有提供对外的创建方式,只能通过反射构造 FSReader
		Compression.Algorithm compressAlgo = trailer.getCompressionCodec();
		Class<?> clazz = Class
				.forName("org.apache.hadoop.hbase.io.hfile.HFileBlock$FSReaderV2");
		java.lang.reflect.Constructor<FSReader> constructor = (Constructor<FSReader>) clazz
				.getConstructor(new Class[] { FSDataInputStream.class,
						FSDataInputStream.class, Compression.Algorithm.class,
						long.class, int.class, HFileSystem.class, Path.class });
		constructor.setAccessible(true);
		fsBlockReader = constructor.newInstance(fsdis, fsdis, compressAlgo,
				size, 0, hfs, path);

		// 创建比较器,比较器是定义在尾文件块中
		RawComparator<byte[]> comparator = FixedFileTrailer
				.createComparator(KeyComparator.class.getName());

		// 创建读取数据块的根索引
		BlockIndexReader dataBlockIndexReader = new HFileBlockIndex.BlockIndexReader(
				comparator, trailer.getNumDataIndexLevels());

		// 创建读取元数据快的根索引
		BlockIndexReader metaBlockIndexReader = new HFileBlockIndex.BlockIndexReader(
				Bytes.BYTES_RAWCOMPARATOR, 1);

		// 创建 HFileBlock 迭代器
		HFileBlock.BlockIterator blockIter = fsBlockReader.blockRange(
				trailer.getLoadOnOpenDataOffset(),
				size - trailer.getTrailerSize());

		// 读取数据文件根索引
		dataBlockIndexReader.readMultiLevelIndexRoot(
				blockIter.nextBlockWithBlockType(BlockType.ROOT_INDEX),
				trailer.getDataIndexCount());

		// 读取元数据根索引
		metaBlockIndexReader.readRootIndex(
				blockIter.nextBlockWithBlockType(BlockType.ROOT_INDEX),
				trailer.getMetaIndexCount());

		// 读取FileInfo块中的信息
		// 由于FileInfo块不是public的,所以定义了一个MyFileInfo,内容跟FileInfo一样
		long fileinfoOffset = trailer.getFileInfoOffset();
		HFileBlock fileinfoBlock = fsBlockReader.readBlockData(fileinfoOffset,
				-1, -1, false);
		MyFileInfo fileinfo = new MyFileInfo();
		fileinfo.readFields(fileinfoBlock.getByteStream());
		int avgKeyLength = Bytes.toInt(fileinfo.get(MyFileInfo.AVG_KEY_LEN));
		int avgValueLength = Bytes
				.toInt(fileinfo.get(MyFileInfo.AVG_VALUE_LEN));
		long entryCount = trailer.getEntryCount();
		System.out.println("avg key length=" + avgKeyLength);
		System.out.println("avg value length=" + avgValueLength);
		System.out.println("entry count=" + entryCount);

		int numDataIndexLevels = trailer.getNumDataIndexLevels();
		if (numDataIndexLevels > 1) {
			// 大于一层
			iteratorRootIndex(dataBlockIndexReader);
		} else {
			// 单根索引
			iteratorSingleIndex(dataBlockIndexReader);
		}

		fsdis.close();
		fsdisNoFsChecksum.close();
	}

	/**
	 * 解析单层索引
	 */
	public void iteratorSingleIndex(BlockIndexReader dataBlockIndex) {
		for (int i = 0; i < dataBlockIndex.getRootBlockCount(); i++) {
			byte[] keyCell = dataBlockIndex.getRootBlockKey(i);
			int blockDataSize = dataBlockIndex.getRootBlockDataSize(i);
			String rowKey = parseKeyCellRowkey(keyCell);
			System.out.println("rowkey=" + rowKey + "\tdata size="
					+ blockDataSize);
		}
	}

	/**
	 * 解析多层索引,首先解析根索引
	 */
	public void iteratorRootIndex(BlockIndexReader dataBlockIndex)
			throws IOException {
		for (int i = 0; i < dataBlockIndex.getRootBlockCount(); i++) {
			long offset = dataBlockIndex.getRootBlockOffset(i);
			int onDiskSize = dataBlockIndex.getRootBlockDataSize(i);
			iteratorNonRootIndex(offset, onDiskSize);
		}
	}

	/**
	 * 递归解析每个中间索引
	 */
	public void iteratorNonRootIndex(long offset, int onDiskSize)
			throws IOException {
		HFileBlock block = fsBlockReader.readBlockData(offset, onDiskSize, -1,
				false);
		if (block.getBlockType().equals(BlockType.LEAF_INDEX)) {
			parseLeafIndex(block);
			return;
		}
		// 开始计算中间层索引的 每个key位置
		ByteBuffer buffer = block.getBufferReadOnly();

		buffer = ByteBuffer.wrap(buffer.array(),
				buffer.arrayOffset() + block.headerSize(),
				buffer.limit() - block.headerSize()).slice();
		int indexCount = buffer.getInt();

		// 二级索引全部偏移量,二级索引数据+二级索引总数(int)+索引文件总大小(int)
		int entriesOffset = Bytes.SIZEOF_INT * (indexCount + 2);
		for (int i = 0; i < indexCount; i++) {
			// 二级索引指向的偏移量
			// 如当前遍历到第一个key,那么二级索引偏移量就是 第二个int(第一个是索引总数)
			int indexKeyOffset = buffer.getInt(Bytes.SIZEOF_INT * (i + 1));
			long blockOffsetIndex = buffer.getLong(indexKeyOffset
					+ entriesOffset);
			int blockSizeIndex = buffer.getInt(indexKeyOffset + entriesOffset
					+ Bytes.SIZEOF_LONG);
			iteratorNonRootIndex(blockOffsetIndex, blockSizeIndex);
		}
	}

	/**
	 * 解析叶索引
	 */
	public void parseLeafIndex(HFileBlock block) {
		// 开始计算中间层索引的 每个key位置
		ByteBuffer buffer = block.getBufferReadOnly();
		buffer = ByteBuffer.wrap(buffer.array(),
				buffer.arrayOffset() + block.headerSize(),
				buffer.limit() - block.headerSize()).slice();
		int indexCount = buffer.getInt();

		// 二级索引全部偏移量,二级索引数据+二级索引总数(int)+索引文件总大小(int)
		int entriesOffset = Bytes.SIZEOF_INT * (indexCount + 2);
		for (int i = 0; i < indexCount; i++) {
			// 二级索引指向的偏移量
			// 如当前遍历到第一个key,那么二级索引偏移量就是 第二个int(第一个是索引总数)
			int indexKeyOffset = buffer.getInt(Bytes.SIZEOF_INT * (i + 1));

			// 全部二级索引长度+key偏移位置+ 块索引offset(long)+块大小(int)
			// 可以计算出真实的key的偏移位置
			int KeyOffset = entriesOffset + indexKeyOffset
					+ SECONDARY_INDEX_ENTRY_OVERHEAD;
			// long blockOffsetIndex =
			// buffer.getLong(indexKeyOffset+entriesOffset);
			int blockSizeIndex = buffer.getInt(indexKeyOffset + entriesOffset
					+ Bytes.SIZEOF_LONG);

			// 计算key的长度
			int length = buffer.getInt(Bytes.SIZEOF_INT * (i + 2))
					- indexKeyOffset - SECONDARY_INDEX_ENTRY_OVERHEAD;

			// 一个key
			// cell包含了key长度(2字节),key,family长度(1字节),family,qualifier,timestampe(8字节),keytype(1字节)
			// 这里只需要key就可以了
			byte[] keyCell = new byte[length];
			System.arraycopy(buffer.array(), buffer.arrayOffset() + KeyOffset,
					keyCell, 0, length);

			String rowKey = parseKeyCellRowkey(keyCell);
			System.out.println("rowkey=" + rowKey + "\t blockSizeIndex="
					+ blockSizeIndex);
		}
	}

	/**
	 * 通过keycell,解析出rowkey
	 */
	public static String parseKeyCellRowkey(byte[] cell) {
		if (cell == null || cell.length < 3) {
			throw new IllegalArgumentException("cell length is illegal");
		}
		int high = (cell[0] >> 8) & 0xFF;
		int low = cell[1] & 0xFF;
		int keySize = high + low;
		byte[] key = new byte[keySize];
		System.arraycopy(cell, 2, key, 0, key.length);
		return Bytes.toString(key);
	}

}

 

工具类:

/**
 * 自定义这样的类原因是HBase的实现是非public类
 */
public class MyFileInfo extends HbaseMapWritable<byte[], byte[]> {
	/**
	 * hfile保留的key,以"hfile."开头
	 */
	public static final String RESERVED_PREFIX = "hfile.";
	
	/**
	 * hfile前缀的二进制表示
	 */
	public static final byte[] RESERVED_PREFIX_BYTES = Bytes
			.toBytes(RESERVED_PREFIX);
	
	/**
	 * last key
	 */
	public static final byte[] LASTKEY = Bytes.toBytes(RESERVED_PREFIX + "LASTKEY");
	
	/**
	 * 平均key长度
	 */
	public static final byte[] AVG_KEY_LEN = Bytes.toBytes(RESERVED_PREFIX + "AVG_KEY_LEN");
	
	/**
	 * 平均value长度
	 */
	public static final byte[] AVG_VALUE_LEN = Bytes.toBytes(RESERVED_PREFIX + "AVG_VALUE_LEN");
	
	/**
	 * 比较器
	 */
	public static final byte[] COMPARATOR = Bytes.toBytes(RESERVED_PREFIX + "COMPARATOR");

	/**
	 * 增加一个key/value 对到file info中,可选的可以检查key的前缀
	 */
	public MyFileInfo append(final byte[] k, final byte[] v, final boolean checkPrefix) throws IOException {
		if (k == null || v == null) {
			throw new NullPointerException("Key nor value may be null");
		}
		if (checkPrefix && isReservedFileInfoKey(k)) {
			throw new IOException("Keys with a " + SaeFileInfo.RESERVED_PREFIX
					+ " are reserved");
		}
		put(k, v);
		return this;
	}

	/**
	 * 检查当前的key是否以保留的前缀开头的
	 */
	public static boolean isReservedFileInfoKey(byte[] key) {
		return Bytes.startsWith(key, SaeFileInfo.RESERVED_PREFIX_BYTES);
	}

}



/**
 * 自定义序列化写入实现类
 *
 */
public class MyWritable implements Writable {

	@Override
	public void readFields(DataInput input) throws IOException {
		input.readInt();
	}

	@Override
	public void write(DataOutput out) throws IOException {
		out.write(123456);
	}
}

 

 

 

 

 

 

 

 

 

  • 大小: 103.6 KB
分享到:
评论

相关推荐

    Scratch图形化编程语言入门与进阶指南

    内容概要:本文全面介绍了Scratch编程语言,包括其历史、发展、特点、主要组件以及如何进行基本和进阶编程操作。通过具体示例,展示了如何利用代码块制作动画、游戏和音乐艺术作品,并介绍了物理模拟、网络编程和扩展库等功能。 适合人群:编程初学者、教育工作者、青少年学生及对编程感兴趣的各年龄段用户。 使用场景及目标:①帮助初学者理解编程的基本概念和逻辑;②提高学生的创造力、逻辑思维能力和问题解决能力;③引导用户通过实践掌握Scratch的基本和高级功能,制作个性化作品。 其他说明:除了基础教学,文章还提供了丰富的学习资源和社区支持,帮助用户进一步提升技能。

    mmexport1734874094130.jpg

    mmexport1734874094130.jpg

    基于simulink的悬架仿真模型,有主动悬架被动悬架天棚控制半主动悬架 1基于pid控制的四自由度主被动悬架仿真模型 2基于模糊控制的二自由度仿真模型,对比pid控制对比被动控制,的比较说明

    基于simulink的悬架仿真模型,有主动悬架被动悬架天棚控制半主动悬架 [1]基于pid控制的四自由度主被动悬架仿真模型 [2]基于模糊控制的二自由度仿真模型,对比pid控制对比被动控制,的比较说明 [3]基于天棚控制的二自由度悬架仿真 以上模型,说明文档齐全,仿真效果明显

    【组合数学答案】组合数学-苏大李凡长版-课后习题答案

    内容概要:本文档是《组合数学答案-网络流传版.pdf》的内容,主要包含了排列组合的基础知识以及一些经典的组合数学题目。这些题目涵盖了从排列数计算、二项式定理的应用到容斥原理的实际应用等方面。通过对这些题目的解析,帮助读者加深对组合数学概念和技巧的理解。 适用人群:适合初学者和有一定基础的学习者。 使用场景及目标:可以在学习组合数学课程时作为练习题参考,也可以在复习考试或准备竞赛时使用,目的是提高解决组合数学问题的能力。 其他说明:文档中的题目覆盖了组合数学的基本知识点,适合逐步深入学习。每个题目都有详细的解答步骤,有助于读者掌握解题思路和方法。

    YOLO算法-雨水排放涵洞模型数据集-1000张图像带标签-.zip

    YOLO系列算法目标检测数据集,包含标签,可以直接训练模型和验证测试,数据集已经划分好,包含数据集配置文件data.yaml,适用yolov5,yolov8,yolov9,yolov7,yolov10,yolo11算法; 包含两种标签格:yolo格式(txt文件)和voc格式(xml文件),分别保存在两个文件夹中,文件名末尾是部分类别名称; yolo格式:<class> <x_center> <y_center> <width> <height>, 其中: <class> 是目标的类别索引(从0开始)。 <x_center> 和 <y_center> 是目标框中心点的x和y坐标,这些坐标是相对于图像宽度和高度的比例值,范围在0到1之间。 <width> 和 <height> 是目标框的宽度和高度,也是相对于图像宽度和高度的比例值; 【注】可以下拉页面,在资源详情处查看标签具体内容;

    操作系统实验 Ucore lab5

    操作系统实验 Ucore lab5

    学生成绩管理系统软件界面

    基于matlab开发的学生成绩管理系统GUI界面,可以实现学生成绩载入,显示,处理及查询。

    NVR-K51-BL-CN-V4.50.010-210322

    老版本4.0固件,(.dav固件包),支持7700N-K4,7900N-K4等K51平台,升级后出现异常或变砖可使用此版本。请核对自己的机器信息,确认适用后在下载。

    YOLO算法-塑料数据集-7张图像带标签-塑料.zip

    YOLO系列算法目标检测数据集,包含标签,可以直接训练模型和验证测试,数据集已经划分好,包含数据集配置文件data.yaml,适用yolov5,yolov8,yolov9,yolov7,yolov10,yolo11算法; 包含两种标签格:yolo格式(txt文件)和voc格式(xml文件),分别保存在两个文件夹中,文件名末尾是部分类别名称; yolo格式:<class> <x_center> <y_center> <width> <height>, 其中: <class> 是目标的类别索引(从0开始)。 <x_center> 和 <y_center> 是目标框中心点的x和y坐标,这些坐标是相对于图像宽度和高度的比例值,范围在0到1之间。 <width> 和 <height> 是目标框的宽度和高度,也是相对于图像宽度和高度的比例值; 【注】可以下拉页面,在资源详情处查看标签具体内容;

    YOLO算法-杂草检测项目数据集-3970张图像带标签-杂草.zip

    YOLO算法-杂草检测项目数据集-3970张图像带标签-杂草.zip

    E008 库洛米(3页).zip

    E008 库洛米(3页).zip

    基于西门子 PLC 的晶圆研磨机自动控制系统设计与实现-论文

    内容概要:本文详细阐述了基于西门子PLC的晶圆研磨机自动控制系统的设计与实现。该系统结合了传感器技术、电机驱动技术和人机界面技术,实现了晶圆研磨过程的高精度和高效率控制。文中详细介绍了控制系统的硬件选型与设计、软件编程与功能实现,通过实验测试和实际应用案例验证了系统的稳定性和可靠性。 适合人群:具备一定的自动化控制和机械设计基础的工程师、研究人员以及从事半导体制造的技术人员。 使用场景及目标:本研究为半导体制造企业提供了一种有效的自动化解决方案,旨在提高晶圆研磨的质量和生产效率,降低劳动强度和生产成本。系统适用于不同规格晶圆的研磨作业,可以实现高精度、高效率、自动化的晶圆研磨过程。 阅读建议:阅读本文时,重点关注晶圆研磨工艺流程和技术要求,控制系统的硬件和软件设计方法,以及实验测试和结果分析。这将有助于读者理解和掌握该自动控制系统的实现原理和应用价值。

    YOLO算法-禾本科杂草数据集-4760张图像带标签.zip

    YOLO系列算法目标检测数据集,包含标签,可以直接训练模型和验证测试,数据集已经划分好,包含数据集配置文件data.yaml,适用yolov5,yolov8,yolov9,yolov7,yolov10,yolo11算法; 包含两种标签格:yolo格式(txt文件)和voc格式(xml文件),分别保存在两个文件夹中,文件名末尾是部分类别名称; yolo格式:<class> <x_center> <y_center> <width> <height>, 其中: <class> 是目标的类别索引(从0开始)。 <x_center> 和 <y_center> 是目标框中心点的x和y坐标,这些坐标是相对于图像宽度和高度的比例值,范围在0到1之间。 <width> 和 <height> 是目标框的宽度和高度,也是相对于图像宽度和高度的比例值; 【注】可以下拉页面,在资源详情处查看标签具体内容;

    深圳建筑安装公司“挖掘机安全操作规程”.docx

    深圳建筑安装公司“挖掘机安全操作规程”

    YOLO算法-汽车数据集-120张图像带标签-汽车.zip

    YOLO系列算法目标检测数据集,包含标签,可以直接训练模型和验证测试,数据集已经划分好,包含数据集配置文件data.yaml,适用yolov5,yolov8,yolov9,yolov7,yolov10,yolo11算法; 包含两种标签格:yolo格式(txt文件)和voc格式(xml文件),分别保存在两个文件夹中,文件名末尾是部分类别名称; yolo格式:<class> <x_center> <y_center> <width> <height>, 其中: <class> 是目标的类别索引(从0开始)。 <x_center> 和 <y_center> 是目标框中心点的x和y坐标,这些坐标是相对于图像宽度和高度的比例值,范围在0到1之间。 <width> 和 <height> 是目标框的宽度和高度,也是相对于图像宽度和高度的比例值; 【注】可以下拉页面,在资源详情处查看标签具体内容;

    大题解题方法等4个文件.zip

    大题解题方法等4个文件.zip

    保障性安居工程考评内容和评价标准.docx

    保障性安居工程考评内容和评价标准.docx

    监督机构检查记录表.docx

    监督机构检查记录表.docx

    (177588850)基于java+mysql+swing的学生选课成绩信息系统

    该项目适合初学者进行学习,有效的掌握java、swing、mysql等技术的基础知识。资源包含源码、视频和文档 资源下载|如果你正在做毕业设计,需要源码和论文,各类课题都可以,私聊我。 商务合作|如果你是在校大学生,正好你又懂语言编程,或者你可以找来需要做毕设的伙伴,私聊我。。内容来源于网络分享,如有侵权请联系我删除。另外如果没有积分的同学需要下载,请私信我。

    218) Leverage - 创意机构与作品集 WordPress 主题 2.2.7.zip

    218) Leverage - 创意机构与作品集 WordPress 主题 2.2.7.zip

Global site tag (gtag.js) - Google Analytics